/*最初版本*/
// package JiSuanQi;

// import java.awt.BorderLayout;
// import java.awt.Button;
// import java.awt.Color;
// import java.awt.FlowLayout;
// import java.awt.Font;
// import java.awt.GridLayout;
// import java.awt.HeadlessException;
// import java.awt.Insets;
// import java.awt.event.ActionEvent;
// import java.awt.event.ActionListener;

// import javax.swing.JButton;
// import javax.swing.JFrame;
// import javax.swing.JPanel;
// import javax.swing.JTextArea;
// import javax.swing.JTextField;
// import javax.swing.event.CaretEvent;
// import javax.swing.event.CaretListener;

// /**
//  * 计算器类，继承自JFrame，实现了ActionListener和CaretListener接口
//  */
// public class Calculator extends JFrame implements ActionListener, CaretListener {
//     private JTextField textResult, textReview;
//     private JButton btns[] = new JButton[30];
//     private String str;

//     /**
//      * 构造方法，初始化计算器界面和组件
//      * @param str 窗口标题
//      */
//     public Calculator(String str) {
//         super(str);
//         this.setBounds(600, 150, 220, 320);
//         this.setDefaultCloseOperation(EXIT_ON_CLOSE);
//         this.setResizable(false);
//         this.getContentPane().setBackground(Color.lightGray);
//         this.getContentPane().setLayout(new BorderLayout());
//         JPanel p1 = new JPanel();
//         p1.setLayout(new BorderLayout(0, 0));
//         textResult = new JTextField("0", 5);

//         textResult.setHorizontalAlignment(JTextField.RIGHT);
//         textResult.setFont(new Font("a", Font.BOLD, 20));
//         textReview = new JTextField(textResult.getText());
//         textReview.setHorizontalAlignment(JTextField.RIGHT);
//         textReview.setEditable(false);
//         textReview.setFont(new Font("v", Font.BOLD, 12));
//         JPanel p1_north = new JPanel();// 设置布局
//         p1.add(p1_north, BorderLayout.NORTH);
//         JPanel p1_west = new JPanel();
//         p1.add(p1_west, BorderLayout.WEST);
//         JPanel p1_east = new JPanel();
//         p1.add(p1_east, BorderLayout.EAST);
//         JPanel ppp = new JPanel();
//         ppp.setLayout(new GridLayout(2, 1, 0, -2));// 更加简洁
//         ppp.add(textReview);
//         ppp.add(textResult);
//         p1.add(ppp, BorderLayout.CENTER);
//         p1.add(p1_west, BorderLayout.WEST);
//         JPanel p1_south = new JPanel();
//         p1.add(p1_south, BorderLayout.SOUTH);
//         this.getContentPane().add(p1, BorderLayout.NORTH);

//         JPanel p2 = new JPanel();
//         p2.setLayout(new GridLayout(6, 5, 10, 10));
//         btns = get(btns);
//         for (int i = 0; i < btns.length; i++) {
//             p2.add(btns[i]);
//             btns[i].setMargin(new Insets(0, 0, 0, 0));// 设置按钮的边缘空余部分为0
//             if (i == btns.length - 1) {
//                 btns[i].setFont(new Font("b", Font.ROMAN_BASELINE, 12));
//             } else {
//                 btns[i].setFont(new Font("b", Font.ROMAN_BASELINE, 15));
//             }
//             btns[i].addActionListener(this);// 一键事件监听
//         }
//         this.getContentPane().add(p2, BorderLayout.CENTER);
//         JPanel p3 = new JPanel();
//         this.getContentPane().add(p3, BorderLayout.WEST);
//         JPanel p4 = new JPanel();
//         this.getContentPane().add(p4, BorderLayout.EAST);
//         JPanel p5 = new JPanel();
//         this.getContentPane().add(p5, BorderLayout.SOUTH);

//         // 添加文本监听器
//         textResult.addCaretListener(this);
//         textReview.addCaretListener(this);
//         this.setVisible(true);
//     }

//     /**
//      * 获取按钮数组并初始化按钮
//      * @param btns2 按钮数组
//      * @return 初始化后的按钮数组
//      */
//     private JButton[] get(JButton[] btns2) {
//         btns[0] = new JButton("MC");
//         btns[1] = new JButton("MR");
//         btns[2] = new JButton("MS");
//         btns[3] = new JButton("M+");
//         btns[4] = new JButton("M-");

//         btns[5] = new JButton("←");
//         btns[6] = new JButton("CE");
//         btns[7] = new JButton("C");
//         btns[8] = new JButton("±");
//         btns[9] = new JButton("√");

//         btns[10] = new JButton("7");
//         btns[11] = new JButton("8");
//         btns[12] = new JButton("9");
//         btns[13] = new JButton("/");
//         btns[14] = new JButton("%");

//         btns[15] = new JButton("4");
//         btns[16] = new JButton("5");
//         btns[17] = new JButton("6");
//         btns[18] = new JButton("*");
//         btns[19] = new JButton("1/x");

//         btns[20] = new JButton("1");
//         btns[21] = new JButton("2");
//         btns[22] = new JButton("3");
//         btns[23] = new JButton("-");
//         btns[24] = new JButton("x^2");

//         btns[25] = new JButton("0");
//         btns[26] = new JButton(".");
//         btns[27] = new JButton("=");
//         btns[28] = new JButton("+");
//         btns[29] = new JButton("OFF");
//         return btns;
//     }

//     /**
//      * 处理按钮的点击事件
//      */
//     public void actionPerformed(ActionEvent e) {
//         if (e.getSource() == btns[0]) {

//         } else if (e.getSource() == btns[0]) {

//         } else if (e.getSource() == btns[1]) {

//         } else if (e.getSource() == btns[2]) {

//         } else if (e.getSource() == btns[3]) {

//         } else if (e.getSource() == btns[4]) {

//         } else if (e.getSource() == btns[5]) {
//             str = textResult.getText();
//             String s = "";
//             if (str.length() == 1) {
//                 textResult.setText("0");
//             } else {
//                 for (int i = 0; i < str.length() - 1; i++) {
//                     s += "" + str.charAt(i);
//                 }
//                 System.out.println(str.length());
//                 textResult.setText(s);
//             }

//         } else if (e.getSource() == btns[6]) {

//         } else if (e.getSource() == btns[7]) {
//             textResult.setText("0");
//             textReview.setText("");
//         } else if (e.getSource() == btns[8]) {
//             math();
//             String str = textReview.getText();
//             String s = "";
//             if (str.charAt(0) == '-') {
//                 for (int i = 1; i < str.length(); i++) {
//                     s += str.charAt(i);
//                 }
//                 textReview.setText(s);
//             } else {
//                 s = "-";
//                 for (int i = 0; i < str.length(); i++) {
//                     s += str.charAt(i);
//                 }
//                 textReview.setText(s);
//             }
//         } else if (e.getSource() == btns[9]) {
//             math();
//             String str = textResult.getText();
//             if (!str.equalsIgnoreCase("")) {
//                 double s = 0;
//                 try {
//                     s = Integer.parseInt(str) * 1.0;
//                     s = Math.sqrt(s);

//                 } catch (NumberFormatException e1) {
//                     try {
//                         s = Double.parseDouble(str);
//                         s = Math.sqrt(s);
//                     } catch (NumberFormatException e2) {

//                     }
//                 }
//                 textResult.setText("" + s);
//             } else {
//                 str = textReview.getText();
//                 double s = 0;
//                 try {
//                     s = Integer.parseInt(str);
//                     s = Math.sqrt(s);
//                 } catch (NumberFormatException e1) {
//                     try {
//                         s = Double.parseDouble(str);
//                         s = Math.sqrt(s);
//                     } catch (NumberFormatException e2) {

//                     }
//                 }
//                 textReview.setText("" + s);
//             }

//         } else if (e.getSource() == btns[10]) {
//             number(btns[10].getText());
//         } else if (e.getSource() == btns[11]) {
//             number(btns[11].getText());
//         } else if (e.getSource() == btns[12]) {
//             number(btns[12].getText());
//         } else if (e.getSource() == btns[13]) {
//             math();
//             str = textResult.getText();
//             String s = textReview.getText();
//             textReview.setText(s + str + btns[13].getText());
//             textResult.setText("0");
//         } else if (e.getSource() == btns[14]) {
//             math();
//             String str = textResult.getText();
//             if (!str.equalsIgnoreCase("")) {
//                 double s = 0;
//                 try {
//                     s = Integer.parseInt(str) * 1.00 / 100;

//                 } catch (NumberFormatException e1) {
//                     try {
//                         s = Double.parseDouble(str) / 100;
//                     } catch (NumberFormatException e2) {

//                     }
//                 }
//                 textResult.setText("" + s);
//             } else {
//                 str = textReview.getText();
//                 double s = 0;
//                 try {
//                     s = Integer.parseInt(str) * 1.00 / 100;

//                 } catch (NumberFormatException e1) {
//                     try {
//                         s = Double.parseDouble(str) / 100;
//                     } catch (NumberFormatException e2) {

//                     }
//                 }
//                 textReview.setText("" + s);
//             }

//         } else if (e.getSource() == btns[15]) {
//             number(btns[15].getText());
//         } else if (e.getSource() == btns[16]) {
//             number(btns[16].getText());
//         } else if (e.getSource() == btns[17]) {
//             number(btns[17].getText());
//         } else if (e.getSource() == btns[18]) {
//             math();
//             str = textResult.getText();
//             String s = textReview.getText();
//             textReview.setText(s + str + btns[18].getText());
//             textResult.setText("0");
//         } else if (e.getSource() == btns[19]) {
//             math();
//             str = textResult.getText();
//             if (!str.equalsIgnoreCase("")) {
//                 double s = 0;
//                 try {
//                     s = Integer.parseInt(str);
//                     s = 1.0 / s;
//                 } catch (NumberFormatException e1) {
//                     try {
//                         s = Double.parseDouble(str);
//                         s = 1.0 / s;
//                     } catch (NumberFormatException e2) {

//                     }
//                 }
//                 textResult.setText("" + s);
//             } else {
//                 str = textReview.getText();
//                 double s = 0;
//                 try {
//                     s = Integer.parseInt(str);
//                     s = 1.0 / s;

//                 } catch (NumberFormatException e1) {
//                     try {
//                         s = Double.parseDouble(str);
//                         s = 1.0 / s;
//                     } catch (NumberFormatException e2) {

//                     }
//                 }
//                 textReview.setText("" + s);
//             }
//         } else if (e.getSource() == btns[20]) {
//             number(btns[20].getText());
//         } else if (e.getSource() == btns[21]) {
//             number(btns[21].getText());
//         } else if (e.getSource() == btns[22]) {
//             number(btns[22].getText());
//         } else if (e.getSource() == btns[23]) {
//             math();
//             str = textResult.getText();
//             String s = textReview.getText();
//             textReview.setText(s + str + btns[23].getText());
//             textResult.setText("0");
//         } else if (e.getSource() == btns[24]) {
//             math();
//             String str = textResult.getText();
//             if (!str.equalsIgnoreCase("")) {
//                 try {
//                     long s = Integer.parseInt(str);
//                     s = s * s;
//                     textResult.setText("" + s);
//                 } catch (NumberFormatException e1) {
//                     try {
//                         double s = Double.parseDouble(str);
//                         s = s * s;
//                         textResult.setText("" + s);
//                     } catch (NumberFormatException e2) {

//                     }

//                 }

//             } else {
//                 str = textReview.getText();
//                 try {
//                     long s = Integer.parseInt(str);
//                     s = s * s;
//                     textReview.setText("" + s);
//                 } catch (NumberFormatException e1) {
//                     try {
//                         double s = Double.parseDouble(str);
//                         s = s * s;
//                         textReview.setText("" + s);
//                     } catch (NumberFormatException e2) {

//                     }
//                 }

//             }
//         } else if (e.getSource() == btns[25]) {
//             number(btns[25].getText());
//         } else if (e.getSource() == btns[26]) {
//             str = textResult.getText();
//             textResult.setText(str + btns[26].getText());
//         } else if (e.getSource() == btns[27]) {
//             math();
//         } else if (e.getSource() == btns[28]) {
//             math();
//             str = textResult.getText();
//             String s = textReview.getText();
//             textReview.setText(s + str + btns[28].getText());
//             textResult.setText("0");
//         } else if (e.getSource() == btns[29]) {
//             System.exit(0);
//         }
//     }

//     /**
//      * 执行数学运算
//      */
//     private void math() {
//         String str = textReview.getText() + textResult.getText();
//         System.out.println(textReview.getText());

//         for (int i = 1; i < str.length(); i++) {
//             if (("" + str.charAt(i)).equals("+")) {
//                 String[] s = str.split("\\+");
//                 System.out.println(s[0] + "   " + s[1]);
//                 try {
//                     int sum = Integer.parseInt(s[0]) + Integer.parseInt(s[1]);
//                     textResult.setText("");
//                     textReview.setText("" + sum);
//                 } catch (NumberFormatException e1) {
//                     try {
//                         double sum = Double.parseDouble(s[0]) + Double.parseDouble(s[1]);
//                         textResult.setText("");
//                         textReview.setText("" + sum);
//                     } catch (NumberFormatException e2) {
//                         e2.printStackTrace();
//                     }
//                 }
//             }
//             if (("" + str.charAt(i)).equals("-")) {
//                 String[] s = str.split("\\-");
//                 if (str.charAt(0) == '-') {
//                     s[s.length - 2] = "-" + s[s.length - 2];
//                 }
//                 try {
//                     int sum = Integer.parseInt(s[s.length - 2]) - Integer.parseInt(s[s.length - 1]);
//                     textResult.setText("");
//                     textReview.setText("" + sum);
//                 } catch (NumberFormatException e1) {
//                     try {
//                         double sum = Double.parseDouble(s[0]) - Double.parseDouble(s[1]);
//                         textResult.setText("");
//                         textReview.setText("" + sum);
//                     } catch (NumberFormatException e2) {

//                     }
//                 }
//             }
//             if (("" + str.charAt(i)).equals("*")) {
//                 String[] s = str.split("\\*");
//                 try {
//                     int sum = Integer.parseInt(s[0]) * Integer.parseInt(s[1]);
//                     textResult.setText("");
//                     textReview.setText("" + sum);
//                 } catch (NumberFormatException e1) {
//                     try {
//                         double sum = Double.parseDouble(s[0]) * Double.parseDouble(s[1]);
//                         textResult.setText("");
//                         textReview.setText("" + sum);
//                     } catch (NumberFormatException e2) {
//                         e2.printStackTrace();
//                     }
//                 }
//             }
//             if (("" + str.charAt(i)).equals("/")) {
//                 String[] s = str.split("\\/");
//                 try {
//                     if (Integer.parseInt(s[0]) % Integer.parseInt(s[1]) == 0) {
//                         int sum = Integer.parseInt(s[0]) / Integer.parseInt(s[1]);
//                         textResult.setText("");
//                         textReview.setText("" + sum);
//                     } else {
//                         double sum = 1.0 * Integer.parseInt(s[0]) / Integer.parseInt(s[1]);
//                         textResult.setText("");
//                         textReview.setText("" + sum);
//                     }

//                 } catch (NumberFormatException e1) {
//                     try {
//                         double sum = Double.parseDouble(s[0]) / Double.parseDouble(s[1]);
//                         textResult.setText("");
//                         textReview.setText("" + sum);
//                     } catch (NumberFormatException e2) {
//                         e2.printStackTrace();
//                     }
//                 }
//             }
//         }
//     }

//     /**
//      * 处理数字按钮的输入
//      * @param text 输入的数字文本
//      */
//     private void number(String text) {
//         str = textResult.getText();
//         try {
//             int s = Integer.parseInt(str);
//             if (s == 0) {
//                 textResult.setText(text);
//             } else {
//                 textResult.setText(str + text);
//             }
//         } catch (NumberFormatException e1) {
//             try {
//                 double s = Double.parseDouble(str);
//                 textResult.setText(str + text);
//             } catch (NumberFormatException e2) {
//                 // e2.printStackTrace();
//             }
//         }
//     }

//     /**
//      * 主程序入口
//      * @param args 命令行参数
//      */
//     public static void main(String[] args) {
//         new Calculator("计算器");
//     }

//     @Override
//     public void caretUpdate(CaretEvent e) {
//         // TODO Auto-generated method stub
//     }
// }

/****************每行都增加了注释******************************/
// package JiSuanQi;

// import java.awt.BorderLayout;
// import java.awt.Button;
// import java.awt.Color;
// import java.awt.FlowLayout;
// import java.awt.Font;
// import java.awt.GridLayout;
// import java.awt.HeadlessException;
// import java.awt.Insets;
// import java.awt.event.ActionEvent;
// import java.awt.event.ActionListener;

// import javax.swing.JButton;
// import javax.swing.JFrame;
// import javax.swing.JPanel;
// import javax.swing.JTextArea;
// import javax.swing.JTextField;
// import javax.swing.event.CaretEvent;
// import javax.swing.event.CaretListener;

// /**
//  * 计算器类，继承自JFrame，实现了ActionListener和CaretListener接口
//  */
// public class Calculator extends JFrame implements ActionListener, CaretListener { // 定义Calculator类，继承自JFrame并实现ActionListener和CaretListener接口
//     private JTextField textResult, textReview; // 定义两个文本框，一个用于显示结果，另一个用于显示输入的数学表达式
//     private JButton btns[] = new JButton[30]; // 定义一个按钮数组，预留30个按钮
//     private String str; // 声明一个字符串变量，用于存储文本框的内容

//     /**
//      * 构造方法，初始化计算器界面和组件
//      * 
//      * @param str 窗口标题
//      */
//     public Calculator(String str) { // 构造方法接收窗口标题参数
//         super(str); // 调用父类构造方法设置窗口标题
//         this.setBounds(600, 150, 220, 320); // 设置窗口的大小和位置
//         this.setDefaultCloseOperation(EXIT_ON_CLOSE); // 设置关闭窗口时退出程序
//         this.setResizable(false); // 不允许调整窗口大小
//         this.getContentPane().setBackground(Color.lightGray); // 设置内容面板的背景颜色
//         this.getContentPane().setLayout(new BorderLayout()); // 设置布局为边界布局

//         JPanel p1 = new JPanel(); // 创建一个新的JPanel
//         p1.setLayout(new BorderLayout(0, 0)); // 设置面板的布局为边界布局
//         textResult = new JTextField("0", 5); // 创建结果文本框，初始值为0，宽度为5

//         textResult.setHorizontalAlignment(JTextField.RIGHT); // 设置文本框内容右对齐
//         textResult.setFont(new Font("a", Font.BOLD, 20)); // 设置文本框字体

//         textReview = new JTextField(textResult.getText()); // 创建审查文本框，初始值为结果文本框的内容
//         textReview.setHorizontalAlignment(JTextField.RIGHT); // 设置审查文本框内容右对齐
//         textReview.setEditable(false); // 设置审查文本框为只读
//         textReview.setFont(new Font("v", Font.BOLD, 12)); // 设置审查文本框字体

//         JPanel p1_north = new JPanel(); // 创建北部面板
//         p1.add(p1_north, BorderLayout.NORTH); // 将北部面板添加到主面板的北部

//         JPanel p1_west = new JPanel(); // 创建西部面板
//         p1.add(p1_west, BorderLayout.WEST); // 将西部面板添加到主面板的西部

//         JPanel p1_east = new JPanel(); // 创建东部面板
//         p1.add(p1_east, BorderLayout.EAST); // 将东部面板添加到主面板的东部

//         JPanel ppp = new JPanel(); // 创建一个用于显示文本框的面板
//         ppp.setLayout(new GridLayout(2, 1, 0, -2)); // 设置为2行1列的网格布局
//         ppp.add(textReview); // 添加审查文本框
//         ppp.add(textResult); // 添加结果文本框
//         p1.add(ppp, BorderLayout.CENTER); // 将显示文本框的面板添加到主面板的中心

//         p1.add(p1_west, BorderLayout.WEST); // 添加西部面板
//         JPanel p1_south = new JPanel(); // 创建南部面板
//         p1.add(p1_south, BorderLayout.SOUTH); // 添加南部面板

//         this.getContentPane().add(p1, BorderLayout.NORTH); // 将主面板添加到内容面板的北部

//         JPanel p2 = new JPanel(); // 创建一个面板用于放置按钮
//         p2.setLayout(new GridLayout(6, 5, 10, 10)); // 设置为6行5列的网格布局
//         btns = get(btns); // 初始化按钮数组

//         for (int i = 0; i < btns.length; i++) { // 遍历按钮数组
//             p2.add(btns[i]); // 将每个按钮添加到面板中
//             btns[i].setMargin(new Insets(0, 0, 0, 0)); // 设置按钮的边缘空余部分为0
//             if (i == btns.length - 1) { // 如果是最后一个按钮
//                 btns[i].setFont(new Font("b", Font.ROMAN_BASELINE, 12)); // 设置小字体
//             } else { // 其他按钮
//                 btns[i].setFont(new Font("b", Font.ROMAN_BASELINE, 15)); // 设置大字体
//             }
//             btns[i].addActionListener(this); // 为每个按钮添加事件监听器
//         }
//         this.getContentPane().add(p2, BorderLayout.CENTER); // 将按钮面板添加到内容面板的中心

//         JPanel p3 = new JPanel(); // 创建西部面板
//         this.getContentPane().add(p3, BorderLayout.WEST); // 将西部面板添加到内容面板的西部

//         JPanel p4 = new JPanel(); // 创建东部面板
//         this.getContentPane().add(p4, BorderLayout.EAST); // 将东部面板添加到内容面板的东部

//         JPanel p5 = new JPanel(); // 创建南部面板
//         this.getContentPane().add(p5, BorderLayout.SOUTH); // 将南部面板添加到内容面板的南部

//         // 添加文本监听器
//         textResult.addCaretListener(this); // 为结果文本框添加光标监听器
//         textReview.addCaretListener(this); // 为审查文本框添加光标监听器
//         this.setVisible(true); // 设置窗口可见
//     }

//     /**
//      * 获取按钮数组并初始化按钮
//      * 
//      * @param btns2 按钮数组
//      * @return 初始化后的按钮数组
//      */
//     private JButton[] get(JButton[] btns2) { // 定义一个方法，用于初始化按钮数组并返回它
//         btns[0] = new JButton("MC"); // 初始化第0个按钮，标签为“MC”（记忆清除）
//         btns[1] = new JButton("MR"); // 初始化第1个按钮，标签为“MR”（记忆召回）
//         btns[2] = new JButton("MS"); // 初始化第2个按钮，标签为“MS”（记忆存储）
//         btns[3] = new JButton("M+"); // 初始化第3个按钮，标签为“M+”（记忆加）
//         btns[4] = new JButton("M-"); // 初始化第4个按钮，标签为“M-”（记忆减）

//         btns[5] = new JButton("←"); // 初始化第5个按钮，标签为“←”（退格）
//         btns[6] = new JButton("CE"); // 初始化第6个按钮，标签为“CE”（清除当前输入）
//         btns[7] = new JButton("C"); // 初始化第7个按钮，标签为“C”（清除所有）
//         btns[8] = new JButton("±"); // 初始化第8个按钮，标签为“±”（正负号切换）
//         btns[9] = new JButton("√"); // 初始化第9个按钮，标签为“√”（开方）

//         btns[10] = new JButton("7"); // 初始化第10个按钮，标签为“7”
//         btns[11] = new JButton("8"); // 初始化第11个按钮，标签为“8”
//         btns[12] = new JButton("9"); // 初始化第12个按钮，标签为“9”
//         btns[13] = new JButton("/"); // 初始化第13个按钮，标签为“/”（除法）
//         btns[14] = new JButton("%"); // 初始化第14个按钮，标签为“%”（百分比）

//         btns[15] = new JButton("4"); // 初始化第15个按钮，标签为“4”
//         btns[16] = new JButton("5"); // 初始化第16个按钮，标签为“5”
//         btns[17] = new JButton("6"); // 初始化第17个按钮，标签为“6”
//         btns[18] = new JButton("*"); // 初始化第18个按钮，标签为“*”（乘法）
//         btns[19] = new JButton("1/x"); // 初始化第19个按钮，标签为“1/x”（倒数）

//         btns[20] = new JButton("1"); // 初始化第20个按钮，标签为“1”
//         btns[21] = new JButton("2"); // 初始化第21个按钮，标签为“2”
//         btns[22] = new JButton("3"); // 初始化第22个按钮，标签为“3”
//         btns[23] = new JButton("-"); // 初始化第23个按钮，标签为“-”（减法）
//         btns[24] = new JButton("x^2"); // 初始化第24个按钮，标签为“x^2”（平方）

//         btns[25] = new JButton("0"); // 初始化第25个按钮，标签为“0”
//         btns[26] = new JButton("."); // 初始化第26个按钮，标签为“.”（小数点）
//         btns[27] = new JButton("="); // 初始化第27个按钮，标签为“=”（等于）
//         btns[28] = new JButton("+"); // 初始化第28个按钮，标签为“+”（加法）
//         btns[29] = new JButton("OFF"); // 初始化第29个按钮，标签为“OFF”（关闭）

//         return btns; // 返回初始化后的按钮数组
//     }

//     /**
//      * 处理按钮的点击事件
//      */
//     public void actionPerformed(ActionEvent e) { // 实现ActionListener接口中的方法，处理按钮点击事件
//         if (e.getSource() == btns[0]) { // 如果点击的是第0个按钮（MC）
//             // 此处可以添加MC按钮的相关逻辑
//         } else if (e.getSource() == btns[1]) { // 如果点击的是第1个按钮（MR）
//             // 此处可以添加MR按钮的相关逻辑
//         } else if (e.getSource() == btns[2]) { // 如果点击的是第2个按钮（MS）
//             // 此处可以添加MS按钮的相关逻辑
//         } else if (e.getSource() == btns[3]) { // 如果点击的是第3个按钮（M+）
//             // 此处可以添加M+按钮的相关逻辑
//         } else if (e.getSource() == btns[4]) { // 如果点击的是第4个按钮（M-）
//             // 此处可以添加M-按钮的相关逻辑
//         } else if (e.getSource() == btns[5]) { // 如果点击的是第5个按钮（←，退格）
//             str = textResult.getText(); // 获取结果文本框的内容
//             String s = ""; // 创建一个空字符串用于存储新内容
//             if (str.length() == 1) { // 如果字符串长度为1
//                 textResult.setText("0"); // 设置结果文本框为0
//             } else { // 如果字符串长度大于1
//                 for (int i = 0; i < str.length() - 1; i++) { // 遍历字符串直到倒数第二个字符
//                     s += "" + str.charAt(i); // 将字符添加到新字符串中
//                 }
//                 System.out.println(str.length()); // 打印字符串的长度（用于调试）
//                 textResult.setText(s); // 更新结果文本框为新字符串
//             }

//         } else if (e.getSource() == btns[6]) { // 如果点击的是第6个按钮（CE，清除当前输入）
//             // 此处可以添加CE按钮的相关逻辑
//         } else if (e.getSource() == btns[7]) { // 如果点击的是第7个按钮（C，清除所有）
//             textResult.setText("0"); // 将结果文本框清空并设置为0
//             textReview.setText(""); // 清空审查文本框
//         } else if (e.getSource() == btns[8]) { // 如果点击的是第8个按钮（±，正负号切换）
//             math(); // 先执行数学运算（以确保状态更新）
//             String str = textReview.getText(); // 获取审查文本框的内容
//             String s = ""; // 创建一个空字符串用于存储新内容
//             if (str.charAt(0) == '-') { // 如果字符串以负号开头
//                 for (int i = 1; i < str.length(); i++) { // 从第一个字符开始遍历
//                     s += str.charAt(i); // 复制后面的所有字符
//                 }
//                 textReview.setText(s); // 更新审查文本框为去掉负号的新字符串
//             } else { // 如果字符串不是以负号开头
//                 s = "-"; // 添加负号
//                 for (int i = 0; i < str.length(); i++) { // 遍历所有字符
//                     s += str.charAt(i); // 复制所有字符
//                 }
//                 textReview.setText(s); // 更新审查文本框为添加负号的新字符串
//             }
//         } else if (e.getSource() == btns[9]) { // 如果点击的是第9个按钮（√，开方）
//             math(); // 执行数学运算，确保状态更新
//             String str = textResult.getText(); // 获取结果文本框的内容
//             if (!str.equalsIgnoreCase("")) { // 如果结果文本框不为空
//                 double s = 0; // 初始化一个double变量用于存储结果
//                 try {
//                     s = Integer.parseInt(str) * 1.0; // 尝试将字符串解析为整数并赋值给s
//                     s = Math.sqrt(s); // 计算s的平方根
//                 } catch (NumberFormatException e1) { // 捕获数字格式异常
//                     try {
//                         s = Double.parseDouble(str); // 尝试将字符串解析为双精度浮点数
//                         s = Math.sqrt(s); // 计算s的平方根
//                     } catch (NumberFormatException e2) { // 捕获数字格式异常
//                         // 此处可以添加错误处理逻辑
//                     }
//                 }
//                 textResult.setText("" + s); // 将计算结果转换为字符串并显示在结果文本框
//             } else { // 如果结果文本框为空
//                 str = textReview.getText(); // 获取审查文本框的内容
//                 double s = 0; // 初始化一个double变量用于存储结果
//                 try {
//                     s = Integer.parseInt(str); // 尝试将字符串解析为整数
//                     s = Math.sqrt(s); // 计算s的平方根
//                 } catch (NumberFormatException e1) { // 捕获数字格式异常
//                     try {
//                         s = Double.parseDouble(str); // 尝试将字符串解析为双精度浮点数
//                         s = Math.sqrt(s); // 计算s的平方根
//                     } catch (NumberFormatException e2) { // 捕获数字格式异常
//                         // 此处可以添加错误处理逻辑
//                     }
//                 }
//                 textReview.setText("" + s); // 将计算结果转换为字符串并显示在审查文本框
//             }

//         } else if (e.getSource() == btns[10]) { // 如果点击的是第10个按钮（数字7）
//             number(btns[10].getText()); // 调用数字输入处理方法，传入按钮的文本
//         } else if (e.getSource() == btns[11]) { // 如果点击的是第11个按钮（数字8）
//             number(btns[11].getText()); // 调用数字输入处理方法
//         } else if (e.getSource() == btns[12]) { // 如果点击的是第12个按钮（数字9）
//             number(btns[12].getText()); // 调用数字输入处理方法
//         } else if (e.getSource() == btns[13]) { // 如果点击的是第13个按钮（/，除法）
//             math(); // 执行数学运算，确保状态更新
//             str = textResult.getText(); // 获取结果文本框的内容
//             String s = textReview.getText(); // 获取审查文本框的内容
//             textReview.setText(s + str + btns[13].getText()); // 将当前结果和运算符添加到审查文本框
//             textResult.setText("0"); // 清空结果文本框并重置为0
//         } else if (e.getSource() == btns[14]) { // 如果点击的是第14个按钮（%）
//             math(); // 执行数学运算，确保状态更新
//             String str = textResult.getText(); // 获取结果文本框的内容
//             if (!str.equalsIgnoreCase("")) { // 如果结果文本框不为空
//                 double s = 0; // 初始化一个double变量用于存储结果
//                 try {
//                     s = Integer.parseInt(str) * 1.00 / 100; // 尝试将字符串解析为整数并转换为百分比
//                 } catch (NumberFormatException e1) { // 捕获数字格式异常
//                     try {
//                         s = Double.parseDouble(str) / 100; // 尝试将字符串解析为双精度浮点数并转换为百分比
//                     } catch (NumberFormatException e2) { // 捕获数字格式异常
//                         // 此处可以添加错误处理逻辑
//                     }
//                 }
//                 textResult.setText("" + s); // 将计算结果转换为字符串并显示在结果文本框
//             } else { // 如果结果文本框为空
//                 str = textReview.getText(); // 获取审查文本框的内容
//                 double s = 0; // 初始化一个double变量用于存储结果
//                 try {
//                     s = Integer.parseInt(str) * 1.00 / 100; // 尝试将字符串解析为整数并转换为百分比
//                 } catch (NumberFormatException e1) { // 捕获数字格式异常
//                     try {
//                         s = Double.parseDouble(str) / 100; // 尝试将字符串解析为双精度浮点数并转换为百分比
//                     } catch (NumberFormatException e2) { // 捕获数字格式异常
//                         // 此处可以添加错误处理逻辑
//                     }
//                 }
//                 textReview.setText("" + s); // 将计算结果转换为字符串并显示在审查文本框
//             }

//         } else if (e.getSource() == btns[15]) { // 如果点击的是第15个按钮（数字4）
//             number(btns[15].getText()); // 调用数字输入处理方法
//         } else if (e.getSource() == btns[16]) { // 如果点击的是第16个按钮（数字5）
//             number(btns[16].getText()); // 调用数字输入处理方法
//         } else if (e.getSource() == btns[17]) { // 如果点击的是第17个按钮（数字6）
//             number(btns[17].getText()); // 调用数字输入处理方法
//         } else if (e.getSource() == btns[18]) { // 如果点击的是第18个按钮（*，乘法）
//             math(); // 执行数学运算，确保状态更新
//             str = textResult.getText(); // 获取结果文本框的内容
//             String s = textReview.getText(); // 获取审查文本框的内容
//             textReview.setText(s + str + btns[18].getText()); // 将当前结果和运算符添加到审查文本框
//             textResult.setText("0"); // 清空结果文本框并重置为0
//         } else if (e.getSource() == btns[19]) { // 如果点击的是第19个按钮（1/x，倒数）
//             math(); // 执行数学运算，确保状态更新
//             str = textResult.getText(); // 获取结果文本框的内容
//             if (!str.equalsIgnoreCase("")) { // 如果结果文本框不为空
//                 double s = 0; // 初始化一个double变量用于存储结果
//                 try {
//                     s = Integer.parseInt(str); // 尝试将字符串解析为整数
//                     s = 1.0 / s; // 计算倒数
//                 } catch (NumberFormatException e1) { // 捕获数字格式异常
//                     try {
//                         s = Double.parseDouble(str); // 尝试将字符串解析为双精度浮点数
//                         s = 1.0 / s; // 计算倒数
//                     } catch (NumberFormatException e2) { // 捕获数字格式异常
//                         // 此处可以添加错误处理逻辑
//                     }
//                 }
//                 textResult.setText("" + s); // 将结果显示在结果文本框
//             } else { // 如果结果文本框为空
//                 str = textReview.getText(); // 获取审查文本框的内容
//                 double s = 0; // 初始化一个double变量用于存储结果
//                 try {
//                     s = Integer.parseInt(str); // 尝试将字符串解析为整数
//                     s = 1.0 / s; // 计算倒数
//                 } catch (NumberFormatException e1) { // 捕获数字格式异常
//                     try {
//                         s = Double.parseDouble(str); // 尝试将字符串解析为双精度浮点数
//                         s = 1.0 / s; // 计算倒数
//                     } catch (NumberFormatException e2) { // 捕获数字格式异常
//                         // 此处可以添加错误处理逻辑
//                     }
//                 }
//                 textReview.setText("" + s); // 将结果显示在审查文本框
//             }
//         } else if (e.getSource() == btns[20]) { // 如果点击的是第20个按钮（数字1）
//             number(btns[20].getText()); // 调用数字输入处理方法
//         } else if (e.getSource() == btns[21]) { // 如果点击的是第21个按钮（数字2）
//             number(btns[21].getText()); // 调用数字输入处理方法
//         } else if (e.getSource() == btns[22]) { // 如果点击的是第22个按钮（数字3）
//             number(btns[22].getText()); // 调用数字输入处理方法
//         } else if (e.getSource() == btns[23]) { // 如果点击的是第23个按钮（-，减法）
//             math(); // 执行数学运算，确保状态更新
//             str = textResult.getText(); // 获取结果文本框的内容
//             String s = textReview.getText(); // 获取审查文本框的内容
//             textReview.setText(s + str + btns[23].getText()); // 将当前结果和运算符添加到审查文本框
//             textResult.setText("0"); // 清空结果文本框并重置为0
//         } else if (e.getSource() == btns[24]) { // 如果点击的是第24个按钮（x^2，平方）
//             math(); // 执行数学运算，确保状态更新
//             String str = textResult.getText(); // 获取结果文本框的内容
//             if (!str.equalsIgnoreCase("")) { // 如果结果文本框不为空
//                 try {
//                     long s = Integer.parseInt(str); // 尝试将字符串解析为整数
//                     s = s * s; // 计算平方
//                     textResult.setText("" + s); // 将结果显示在结果文本框
//                 } catch (NumberFormatException e1) { // 捕获数字格式异常
//                     try {
//                         double s = Double.parseDouble(str); // 尝试将字符串解析为双精度浮点数
//                         s = s * s; // 计算平方
//                         textResult.setText("" + s); // 将结果显示在结果文本框
//                     } catch (NumberFormatException e2) { // 捕获数字格式异常
//                         // 此处可以添加错误处理逻辑
//                     }
//                 }
//             } else { // 如果结果文本框为空
//                 str = textReview.getText(); // 获取审查文本框的内容
//                 try {
//                     long s = Integer.parseInt(str); // 尝试将字符串解析为整数
//                     s = s * s; // 计算平方
//                     textReview.setText("" + s); // 将结果显示在审查文本框
//                 } catch (NumberFormatException e1) { // 捕获数字格式异常
//                     try {
//                         double s = Double.parseDouble(str); // 尝试将字符串解析为双精度浮点数
//                         s = s * s; // 计算平方
//                         textReview.setText("" + s); // 将结果显示在审查文本框
//                     } catch (NumberFormatException e2) { // 捕获数字格式异常
//                         // 此处可以添加错误处理逻辑
//                     }
//                 }
//             }
//         } else if (e.getSource() == btns[25]) { // 如果点击的是第25个按钮（数字0）
//             number(btns[25].getText()); // 调用数字输入处理方法
//         } else if (e.getSource() == btns[26]) { // 如果点击的是第26个按钮（.，小数点）
//             str = textResult.getText(); // 获取结果文本框的内容
//             textResult.setText(str + btns[26].getText()); // 在结果文本框中添加小数点
//         } else if (e.getSource() == btns[27]) { // 如果点击的是第27个按钮（=，等于）
//             math(); // 执行数学运算，确保状态更新
//         } else if (e.getSource() == btns[28]) { // 如果点击的是第28个按钮（+，加法）
//             math(); // 执行数学运算，确保状态更新
//             str = textResult.getText(); // 获取结果文本框的内容
//             String s = textReview.getText(); // 获取审查文本框的内容
//             textReview.setText(s + str + btns[28].getText()); // 将当前结果和运算符添加到审查文本框
//             textResult.setText("0"); // 清空结果文本框并重置为0
//         } else if (e.getSource() == btns[29]) { // 如果点击的是第29个按钮（OFF，关闭）
//             System.exit(0); // 退出程序
//         }
//     }

//     /**
//      * 执行数学运算
//      */
//     private void math() { // 定义一个私有方法，用于执行数学运算
//         String str = textReview.getText() + textResult.getText(); // 获取审查文本框和结果文本框的内容并拼接
//         System.out.println(textReview.getText()); // 打印审查文本框的内容（用于调试）

//         for (int i = 1; i < str.length(); i++) { // 从第二个字符开始遍历拼接后的字符串
//             if (("" + str.charAt(i)).equals("+")) { // 如果当前字符是加法运算符（+）
//                 String[] s = str.split("\\+"); // 按加号分割字符串成数组
//                 System.out.println(s[0] + "   " + s[1]); // 打印两个操作数（用于调试）
//                 try {
//                     int sum = Integer.parseInt(s[0]) + Integer.parseInt(s[1]); // 尝试将两个操作数解析为整数并相加
//                     textResult.setText(""); // 清空结果文本框
//                     textReview.setText("" + sum); // 将计算结果显示在审查文本框
//                 } catch (NumberFormatException e1) { // 捕获整数解析异常
//                     try {
//                         double sum = Double.parseDouble(s[0]) + Double.parseDouble(s[1]); // 尝试将两个操作数解析为浮点数并相加
//                         textResult.setText(""); // 清空结果文本框
//                         textReview.setText("" + sum); // 将计算结果显示在审查文本框
//                     } catch (NumberFormatException e2) { // 捕获浮点数解析异常
//                         e2.printStackTrace(); // 打印异常堆栈跟踪（用于调试）
//                     }
//                 }
//             }

//             if (("" + str.charAt(i)).equals("-")) { // 如果当前字符是减法运算符（-）
//                 String[] s = str.split("\\-"); // 按减号分割字符串成数组
//                 if (str.charAt(0) == '-') { // 如果字符串以负号开头
//                     s[s.length - 2] = "-" + s[s.length - 2]; // 将减去的数的符号变为负
//                 }
//                 try {
//                     int sum = Integer.parseInt(s[s.length - 2]) - Integer.parseInt(s[s.length - 1]); // 尝试将操作数解析为整数并相减
//                     textResult.setText(""); // 清空结果文本框
//                     textReview.setText("" + sum); // 将计算结果显示在审查文本框
//                 } catch (NumberFormatException e1) { // 捕获整数解析异常
//                     try {
//                         double sum = Double.parseDouble(s[0]) - Double.parseDouble(s[1]); // 尝试将操作数解析为浮点数并相减
//                         textResult.setText(""); // 清空结果文本框
//                         textReview.setText("" + sum); // 将计算结果显示在审查文本框
//                     } catch (NumberFormatException e2) { // 捕获浮点数解析异常
//                         // 处理异常
//                     }
//                 }
//             }

//             if (("" + str.charAt(i)).equals("*")) { // 如果当前字符是乘法运算符（*）
//                 String[] s = str.split("\\*"); // 按乘号分割字符串成数组
//                 try {
//                     int sum = Integer.parseInt(s[0]) * Integer.parseInt(s[1]); // 尝试将操作数解析为整数并相乘
//                     textResult.setText(""); // 清空结果文本框
//                     textReview.setText("" + sum); // 将计算结果显示在审查文本框
//                 } catch (NumberFormatException e1) { // 捕获整数解析异常
//                     try {
//                         double sum = Double.parseDouble(s[0]) * Double.parseDouble(s[1]); // 尝试将操作数解析为浮点数并相乘
//                         textResult.setText(""); // 清空结果文本框
//                         textReview.setText("" + sum); // 将计算结果显示在审查文本框
//                     } catch (NumberFormatException e2) { // 捕获浮点数解析异常
//                         e2.printStackTrace(); // 打印异常堆栈跟踪（用于调试）
//                     }
//                 }
//             }

//             if (("" + str.charAt(i)).equals("/")) { // 如果当前字符是除法运算符（/）
//                 String[] s = str.split("\\/"); // 按除号分割字符串成数组
//                 try {
//                     if (Integer.parseInt(s[0]) % Integer.parseInt(s[1]) == 0) { // 检查是否可以整除
//                         int sum = Integer.parseInt(s[0]) / Integer.parseInt(s[1]); // 执行整数除法
//                         textResult.setText(""); // 清空结果文本框
//                         textReview.setText("" + sum); // 将计算结果显示在审查文本框
//                     } else {
//                         double sum = 1.0 * Integer.parseInt(s[0]) / Integer.parseInt(s[1]); // 执行浮点数除法
//                         textResult.setText(""); // 清空结果文本框
//                         textReview.setText("" + sum); // 将计算结果显示在审查文本框
//                     }
//                 } catch (NumberFormatException e1) { // 捕获整数解析异常
//                     try {
//                         double sum = Double.parseDouble(s[0]) / Double.parseDouble(s[1]); // 尝试将操作数解析为浮点数并执行除法
//                         textResult.setText(""); // 清空结果文本框
//                         textReview.setText("" + sum); // 将计算结果显示在审查文本框
//                     } catch (NumberFormatException e2) { // 捕获浮点数解析异常
//                         e2.printStackTrace(); // 打印异常堆栈跟踪（用于调试）
//                     }
//                 }
//             }
//         }
//     }

//     /**
//      * 处理数字按钮的输入
//      * 
//      * @param text 输入的数字文本
//      */
//     private void number(String text) { // 定义一个私有方法，用于处理数字按钮的输入
//         str = textResult.getText(); // 获取结果文本框中的当前文本并赋值给str
//         try { // 尝试执行以下代码块
//             int s = Integer.parseInt(str); // 将当前文本解析为整数
//             if (s == 0) { // 如果当前值为0
//                 textResult.setText(text); // 将结果文本框的内容设置为当前按钮的文本
//             } else { // 如果当前值不为0
//                 textResult.setText(str + text); // 将当前文本与按钮文本拼接后再次设置到结果文本框
//             }
//         } catch (NumberFormatException e1) { // 捕获整数解析的异常
//             try { // 尝试执行以下代码块
//                 double s = Double.parseDouble(str); // 将当前文本解析为双精度浮点数
//                 textResult.setText(str + text); // 将当前文本与按钮文本拼接后再次设置到结果文本框
//             } catch (NumberFormatException e2) { // 捕获双精度浮点数解析的异常
//                 // e2.printStackTrace(); // 此处可以添加错误处理，例如打印错误堆栈
//             }
//         }
//     }

//     /**
//      * 主程序入口
//      * 
//      * @param args 命令行参数
//      */
//     public static void main(String[] args) {
//         new Calculator("计算器");
//     }

//     @Override
//     public void caretUpdate(CaretEvent e) {
//         // TODO Auto-generated method stub
//     }
// }

/*修改了逻辑， 实现了运算功能*/
// package JiSuanQi;

// import java.awt.BorderLayout;
// import java.awt.Button;
// import java.awt.Color;
// import java.awt.FlowLayout;
// import java.awt.Font;
// import java.awt.GridLayout;
// import java.awt.HeadlessException;
// import java.awt.Insets;
// import java.awt.event.ActionEvent;
// import java.awt.event.ActionListener;
// import java.awt.font.ShapeGraphicAttribute;

// import javax.swing.JButton;
// import javax.swing.JFrame;
// import javax.swing.JPanel;
// import javax.swing.JTextArea;
// import javax.swing.JTextField;
// import javax.swing.event.CaretEvent;
// import javax.swing.event.CaretListener;

// /**
//  * 计算器类，继承自JFrame，实现了ActionListener和CaretListener接口
//  * 
//  * JFrame：
//  * JFrame 是 Swing 包中的一个类，用于创建一个窗口界面。它是所有顶层窗口的基本类型，提供了图形用户界面的框架。
//  * JFrame 可以包含各种图形组件，如按钮、标签、文本框等，通过设置布局管理器，用户可以控制这些组件的显示方式。
//  * 主要的功能包括设置窗口标题、设置窗口大小、设置关闭操作、添加组件和显示窗口等。
//  * 
//  * ActionListener：
//  * ActionListener 是一个接口，用于处理按钮点击等动作事件。当用户在 GUI 中执行某个动作（如点击按钮）时，将触发相应的事件。
//  * 开发者需要实现 actionPerformed(ActionEvent e) 方法，以定义在事件发生时应该执行的操作。
//  * 通过为组件（如按钮）添加这个监听器，可以响应用户的交互。
//  * 
//  * CaretListener：
//  * CaretListener 也是一个接口，用于监听文本组件（如 JTextField 或 JTextArea）中光标的移动事件。
//  * 当文本框中的光标位置变化时，将触发 caretUpdate(CaretEvent e)
//  * 方法，开发者可以在这个方法中处理光标移动后的逻辑，例如更新某些组件的状态或者显示相关信息。
//  * 这个监听器通常用来监控用户在文本框中进行输入或删除操作后的光标位置变化
//  */
// public class Calculator extends JFrame implements ActionListener, CaretListener { // 定义Calculator类，继承自JFrame并实现ActionListener和CaretListener接口
//     private JTextField textResult, textReview; // 定义两个文本框，一个用于显示结果，另一个用于显示输入的数学表达式
//     private JButton btns[] = new JButton[30]; // 定义一个按钮数组，预留30个按钮
//     // private String str1, str2; // str1用于存储历史输入的数学表达式，str2用于存储当前输入的数学表达式
//     private String str;
//     private String memory;

//     /**
//      * 构造方法，初始化计算器界面和组件
//      * 
//      * @param str 窗口标题
//      */
//     public Calculator(String str) { // 构造方法接收窗口标题参数
//         super(str); // 调用父类构造方法设置窗口标题
//         this.setBounds(600, 150, 320, 420); // 设置窗口的大小和位置
//         this.setDefaultCloseOperation(EXIT_ON_CLOSE); // 设置关闭窗口时退出程序
//         this.setResizable(false); // 不允许调整窗口大小
//         this.getContentPane().setBackground(Color.lightGray); // 设置内容面板的背景颜色
//         this.getContentPane().setLayout(new BorderLayout()); // 设置布局为边界布局
//         /*
//          * getContentPane() 方法返回当前窗口的内容面板，内容面板是窗口中用于放置组件的区域。
//          * setLayout(new BorderLayout()) 方法将内容面板的布局管理器设置为 BorderLayout，
//          * 这是一种将组件放置在五个区域的布局方式：北（NORTH）、南（SOUTH）、东（EAST）、西（WEST）和中心（CENTER）。
//          */

//         JPanel p1 = new JPanel(); // 创建一个新的JPanel
//         p1.setLayout(new BorderLayout(0, 0)); // 设置面板的布局为边界布局
//         textResult = new JTextField("0", 5); // 创建结果文本框，初始值为0，宽度为5
//         /* 不一样 */
//         /* ！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！ */

//         textResult.setHorizontalAlignment(JTextField.RIGHT); // 设置文本框内容右对齐
//         textResult.setFont(new Font("a", Font.BOLD, 20)); // 设置文本框字体

//         textReview = new JTextField(textResult.getText()); // 创建审查文本框，初始值为结果文本框的内容
//         textReview.setHorizontalAlignment(JTextField.RIGHT); // 设置审查文本框内容右对齐
//         textReview.setEditable(false); // 设置审查文本框为只读
//         textReview.setFont(new Font("v", Font.BOLD, 12)); // 设置审查文本框字体

//         JPanel p1_north = new JPanel(); // 创建北部面板
//         p1.add(p1_north, BorderLayout.NORTH); // 将北部面板添加到主面板的北部

//         JPanel p1_west = new JPanel(); // 创建西部面板
//         p1.add(p1_west, BorderLayout.WEST); // 将西部面板添加到主面板的西部

//         JPanel p1_east = new JPanel(); // 创建东部面板
//         p1.add(p1_east, BorderLayout.EAST); // 将东部面板添加到主面板的东部

//         JPanel ppp = new JPanel(); // 创建一个用于显示文本框的面板
//         ppp.setLayout(new GridLayout(2, 1, 0, -2)); // 设置为2行1列的网格布局
//         ppp.add(textReview); // 添加审查文本框
//         ppp.add(textResult); // 添加结果文本框
//         p1.add(ppp, BorderLayout.CENTER); // 将显示文本框的面板添加到主面板的中心

//         p1.add(p1_west, BorderLayout.WEST); // 添加西部面板
//         JPanel p1_south = new JPanel(); // 创建南部面板
//         p1.add(p1_south, BorderLayout.SOUTH); // 添加南部面板

//         this.getContentPane().add(p1, BorderLayout.NORTH); // 将主面板添加到内容面板的北部

//         JPanel p2 = new JPanel(); // 创建一个面板用于放置按钮
//         p2.setLayout(new GridLayout(6, 5, 10, 10)); // 设置为6行5列的网格布局
//         btns = get(btns); // 初始化按钮数组

//         for (int i = 0; i < btns.length; i++) { // 遍历按钮数组
//             p2.add(btns[i]); // 将每个按钮添加到面板中
//             btns[i].setMargin(new Insets(0, 0, 0, 0)); // 设置按钮的边缘空余部分为0
//             if (i == btns.length - 1) { // 如果是最后一个按钮
//                 btns[i].setFont(new Font("b", Font.ROMAN_BASELINE, 12)); // 设置小字体
//             } else { // 其他按钮
//                 btns[i].setFont(new Font("b", Font.ROMAN_BASELINE, 15)); // 设置大字体
//             }
//             btns[i].addActionListener(this); // 为每个按钮添加事件监听器
//         }
//         this.getContentPane().add(p2, BorderLayout.CENTER); // 将按钮面板添加到内容面板的中心

//         JPanel p3 = new JPanel(); // 创建西部面板
//         this.getContentPane().add(p3, BorderLayout.WEST); // 将西部面板添加到内容面板的西部

//         JPanel p4 = new JPanel(); // 创建东部面板
//         this.getContentPane().add(p4, BorderLayout.EAST); // 将东部面板添加到内容面板的东部

//         JPanel p5 = new JPanel(); // 创建南部面板
//         this.getContentPane().add(p5, BorderLayout.SOUTH); // 将南部面板添加到内容面板的南部

//         // 添加文本监听器
//         textResult.addCaretListener(this); // 为结果文本框添加光标监听器
//         textReview.addCaretListener(this); // 为审查文本框添加光标监听器
//         this.setVisible(true); // 设置窗口可见
//     }

//     // public Calculator(String str) { // 构造方法接收窗口标题参数
//     // super(str); // 调用父类构造方法设置窗口标题
//     // this.setBounds(600, 150, 320, 420); // 设置窗口的大小和位置
//     // this.setDefaultCloseOperation(EXIT_ON_CLOSE); // 设置关闭窗口时退出程序
//     // this.setResizable(false); // 不允许调整窗口大小
//     // this.getContentPane().setBackground(Color.lightGray); // 设置内容面板的背景颜色
//     // this.getContentPane().setLayout(new BorderLayout()); // 设置布局为边界布局

//     // JPanel p1 = new JPanel(); // 创建一个新的JPanel
//     // p1.setLayout(new BorderLayout(0, 0)); // 设置面板的布局为边界布局

//     // // 初始化文本框
//     // textResult = createTextField("0", 20);
//     // textReview = createTextField(textResult.getText(), 12);
//     // textReview.setEditable(false); // 设置审查文本框为只读

//     // // 设置面板及文本框布局
//     // setupPanels(p1);

//     // this.getContentPane().add(p1, BorderLayout.NORTH); // 将主面板添加到内容面板的北部

//     // JPanel p2 = new JPanel(); // 创建一个面板用于放置按钮
//     // p2.setLayout(new GridLayout(6, 5, 10, 10)); // 设置为6行5列的网格布局
//     // btns = get(btns); // 初始化按钮数组
//     // setupButtons(p2); // 设置按钮

//     // this.getContentPane().add(p2, BorderLayout.CENTER); // 将按钮面板添加到内容面板的中心

//     // // 添加文本监听器
//     // textResult.addCaretListener(this); // 为结果文本框添加光标监听器
//     // textReview.addCaretListener(this); // 为审查文本框添加光标监听器
//     // this.setVisible(true); // 设置窗口可见
//     // }

//     // /**
//     // * 创建文本框的方法
//     // */
//     // private JTextField createTextField(String text, int fontSize) {
//     // JTextField textField = new JTextField(text, 5);
//     // textField.setHorizontalAlignment(JTextField.RIGHT); // 设置文本框内容右对齐
//     // textField.setFont(new Font("Arial", Font.BOLD, fontSize)); // 设置文本框字体
//     // return textField;
//     // }

//     // /**
//     // * 设置面板及文本框布局
//     // */
//     // private void setupPanels(JPanel p1) {
//     // p1.add(createPanel(textReview, textResult), BorderLayout.CENTER);
//     // p1.add(new JPanel(), BorderLayout.WEST); // 西部面板
//     // p1.add(new JPanel(), BorderLayout.EAST); // 东部面板
//     // p1.add(new JPanel(), BorderLayout.SOUTH); // 南部面板
//     // }

//     // /**
//     // * 创建包含两个文本框的显示面板
//     // */
//     // private JPanel createPanel(JTextField topField, JTextField bottomField) {
//     // JPanel panel = new JPanel();
//     // panel.setLayout(new GridLayout(2, 1, 0, -2)); // 设置为2行1列的网格布局
//     // panel.add(topField); // 添加审查文本框
//     // panel.add(bottomField); // 添加结果文本框
//     // return panel;
//     // }

//     // /**
//     // * 设置按钮的方法
//     // */
//     // private void setupButtons(JPanel p2) {
//     // for (JButton btn : btns) { // 遍历按钮数组
//     // p2.add(btn); // 将每个按钮添加到面板中
//     // btn.setMargin(new Insets(0, 0, 0, 0)); // 设置按钮的边缘空余部分为0
//     // btn.setFont(new Font("Arial", Font.ROMAN_BASELINE, btn == btns[btns.length -
//     // 1] ? 12 : 15)); // 设置字体
//     // btn.addActionListener(this); // 为每个按钮添加事件监听器
//     // }
//     // }

//     /**
//      * 获取按钮数组并初始化按钮
//      * 
//      * @param btns2 按钮数组
//      * @return 初始化后的按钮数组
//      */
//     private JButton[] get(JButton[] btns2) { // 定义一个方法，用于初始化按钮数组并返回它
//         String[] buttonLabels = {
//                 "MC", "MR", "MS", "M+", "M-",
//                 "←", "CE", "C", "±", "√",
//                 "7", "8", "9", "/", "%",
//                 "4", "5", "6", "*", "1/x",
//                 "1", "2", "3", "-", "x^2",
//                 "0", ".", "=", "+", "OFF"
//         };

//         for (int i = 0; i < btns.length; i++) {
//             try {
//                 btns[i] = new JButton(buttonLabels[i]); // 初始化按钮
//             } catch (ArrayIndexOutOfBoundsException e) {
//                 System.err.println("按钮初始化异常：" + e.getMessage()); // 错误处理
//             }
//         }

//         return btns; // 返回初始化后的按钮数组
//     }

//     /**
//      * 处理按钮的点击事件
//      */
//     public void actionPerformed(ActionEvent e) { // 实现ActionListener接口中的方法，处理按钮点击事件
//         /*
//          * MC（Memory Clear）：清除存储器中的数值。
//          * MR（Memory Recall）：读取存储器中存储的数值。
//          * MS（Memory Save）：将当前显示的数值存入存储器中。
//          * M+（Memory Add）：将当前显示的数值与存储器中的数值相加，并将结果存入存储器。
//          * M-（Memory Minus，部分计算器无此功能）：用存储器中的数值减去当前显示的数值，并将结果存入存储器（此功能并非所有计算器都具备）。
//          */
//         if (e.getSource() == btns[0]) { // 如果点击的是第0个按钮（MC）
//             memory = "0"; // 将存储器中的数值清零
//         } else if (e.getSource() == btns[1]) { // 如果点击的是第1个按钮（MR）
//             str = memory; // 将结果文本框的内容设置为存储器中的数值
//             textResult.setText(str);
//         } else if (e.getSource() == btns[2]) { // 如果点击的是第2个按钮（MS）
//             memory = textResult.getText(); // 将存储器中的数值设置为结果文本框的内容
//         } else if (e.getSource() == btns[3]) { // 如果点击的是第3个按钮（M+）
//             String str = memory + "+" + textResult.getText();
//             String[] s = str.split("\\+"); // 按加号分割字符串成数组
//             System.out.println(s[0] + "   " + s[1]); // 打印两个操作数（用于调试）
//             try {
//                 int sum = Integer.parseInt(s[0]) + Integer.parseInt(s[1]); // 尝试将两个操作数解析为整数并相加
//                 memory = String.valueOf(sum); // 更新存储器中的数值
//             } catch (NumberFormatException e1) { // 捕获整数解析异常
//                 try {
//                     double sum = Double.parseDouble(s[0]) + Double.parseDouble(s[1]); // 尝试将两个操作数解析为浮点数并相加
//                     memory = String.valueOf(sum); // 更新存储器中的数值
//                 } catch (NumberFormatException e2) { // 捕获浮点数解析异常
//                     e2.printStackTrace(); // 打印异常堆栈跟踪（用于调试）
//                 }
//             }
//         } else if (e.getSource() == btns[4]) { // 如果点击的是第4个按钮（M-）
//             String str = memory + "-" + textResult.getText();
//             String[] s = str.split("\\-"); // 按减号分割字符串成数组
//             if (str.charAt(0) == '-') { // 如果字符串以负号开头
//                 s[s.length - 2] = "-" + s[s.length - 2]; // 将减去的数的符号变为负
//                 /*
//                  * str.charAt(0) == '-'：检查字符串的第一个字符是否为负号。
//                  * 如果是，则认为表达式是一个负数，接下来的操作数（即减去的数）也应为负数。
//                  * 
//                  * s[s.length - 2] = "-" + s[s.length - 2];：
//                  * 找到数组 s 中倒数第二个元素（即被减数），将其前面加上一个负号，从而将它的符号变为负。
//                  * 这是为了确保在后续的减法操作中，计算时能正确处理负数。
//                  */
//             }
//             try {
//                 int sum = Integer.parseInt(s[s.length - 2]) - Integer.parseInt(s[s.length - 1]); // 尝试将操作数解析为整数并相减
//                 memory = String.valueOf(sum); // 更新存储器中的数值
//             } catch (NumberFormatException e1) { // 捕获整数解析异常
//                 try {
//                     double sum = Double.parseDouble(s[0]) - Double.parseDouble(s[1]); // 尝试将操作数解析为浮点数并相减
//                     memory = String.valueOf(sum); // 更新存储器中的数值
//                 } catch (NumberFormatException e2) { // 捕获浮点数解析异常
//                     // 处理异常
//                 }
//             }
//         } else if (e.getSource() == btns[5]) { // 如果点击的是第5个按钮（←，退格）
//             // str2 = textResult.getText(); // 获取结果文本框的内容
//             // if (str2.length() == 1) { // 如果字符串长度为1
//             // textResult.setText("0"); // 设置结果文本框为0
//             // } else { // 如果字符串长度大于1
//             // str2 = str2.substring(0, str.length() - 1);
//             // // System.out.println(str.length()); // 打印字符串的长度（用于调试）
//             // textResult.setText(str2); // 更新结果文本框为新字符串
//             // }
//             str = textResult.getText(); // 获取结果文本框的内容
//             if (str.length() == 1) { // 如果字符串长度为1
//                 textResult.setText("0"); // 设置结果文本框为0
//             } else { // 如果字符串长度大于1
//                 str = str.substring(0, str.length() - 1);
//                 // System.out.println(str.length()); // 打印字符串的长度（用于调试）
//                 textResult.setText(str); // 更新结果文本框为新字符串
//             }
//         } else if (e.getSource() == btns[6]) { // 如果点击的是第6个按钮（CE，清除当前输入）
//             // str2 = "0";
//             textResult.setText("0"); // 清空审查文本框
//         } else if (e.getSource() == btns[7]) { // 如果点击的是第7个按钮（C，清除所有）
//             textResult.setText("0"); // 将结果文本框清空并设置为0
//             textReview.setText(""); // 清空审查文本框
//         } else if (e.getSource() == btns[8]) { // 如果点击的是第8个按钮（±，正负号切换）
//             math(); // 先执行数学运算（以确保状态更新）
//             String str = textReview.getText(); // 获取审查文本框的内容
//             str = str.startsWith("-") ? str.substring(1, str.length()) : "-" + str; // 取反
//             textReview.setText(str); // 更新审查文本框为新字符串
//         } else if (e.getSource() == btns[9]) { // 如果点击的是第9个按钮（√，开方）
//             math(); // 执行数学运算，确保状态更新
//             String str = textResult.getText(); // 获取结果文本框的内容
//             if (!str.equalsIgnoreCase("")) { // 如果结果文本框不为空
//                 double s = 0; // 初始化一个double变量用于存储结果
//                 try {
//                     s = Double.parseDouble(str); // 尝试将字符串解析为双精度浮点数
//                     s = Math.sqrt(s); // 计算s的平方根
//                 } catch (NumberFormatException e2) { // 捕获数字格式异常
//                     // 此处可以添加错误处理逻辑
//                 }
//                 textReview.setText("" + s); // 将计算结果转换为字符串并显示在结果文本框
//                 textResult.setText("0"); // 清空结果文本框并重置为0
//             } else { // 如果结果文本框为空
//                 str = textReview.getText(); // 获取审查文本框的内容
//                 double s = 0; // 初始化一个double变量用于存储结果
//                 try {
//                     s = Double.parseDouble(str); // 尝试将字符串解析为双精度浮点数
//                     s = Math.sqrt(s); // 计算s的平方根
//                 } catch (NumberFormatException e2) { // 捕获数字格式异常
//                     // 此处可以添加错误处理逻辑
//                 }
//                 textReview.setText("" + s); // 将计算结果转换为字符串并显示在审查文本框
//             }
//         } else if (e.getSource() == btns[10]) { // 如果点击的是第10个按钮（数字7）
//             number(btns[10].getText()); // 调用数字输入处理方法，传入按钮的文本
//         } else if (e.getSource() == btns[11]) { // 如果点击的是第11个按钮（数字8）
//             number(btns[11].getText()); // 调用数字输入处理方法
//         } else if (e.getSource() == btns[12]) { // 如果点击的是第12个按钮（数字9）
//             number(btns[12].getText()); // 调用数字输入处理方法
//         } else if (e.getSource() == btns[13]) { // 如果点击的是第13个按钮（/，除法）
//             math(); // 执行数学运算，确保状态更新
//             str = textResult.getText(); // 获取结果文本框的内容
//             String s = textReview.getText(); // 获取审查文本框的内容
//             textReview.setText(s + str + btns[13].getText()); // 将当前结果和运算符添加到审查文本框
//             textResult.setText("0"); // 清空结果文本框并重置为0
//         } else if (e.getSource() == btns[14]) { // 如果点击的是第14个按钮（%）
//             math(); // 执行数学运算，确保状态更新
//             String str = textResult.getText(); // 获取结果文本框的内容
//             if (!str.equalsIgnoreCase("")) { // 如果结果文本框不为空
//                 double s = 0; // 初始化一个double变量用于存储结果
//                 try {
//                     s = Integer.parseInt(str) * 1.00 / 100; // 尝试将字符串解析为整数并转换为百分比
//                 } catch (NumberFormatException e1) { // 捕获数字格式异常
//                     try {
//                         s = Double.parseDouble(str) / 100; // 尝试将字符串解析为双精度浮点数并转换为百分比
//                     } catch (NumberFormatException e2) { // 捕获数字格式异常
//                         // 此处可以添加错误处理逻辑
//                     }
//                 }
//                 textResult.setText("" + s); // 将计算结果转换为字符串并显示在结果文本框
//             } else { // 如果结果文本框为空
//                 str = textReview.getText(); // 获取审查文本框的内容
//                 double s = 0; // 初始化一个double变量用于存储结果
//                 try {
//                     s = Integer.parseInt(str) * 1.00 / 100; // 尝试将字符串解析为整数并转换为百分比
//                 } catch (NumberFormatException e1) { // 捕获数字格式异常
//                     try {
//                         s = Double.parseDouble(str) / 100; // 尝试将字符串解析为双精度浮点数并转换为百分比
//                     } catch (NumberFormatException e2) { // 捕获数字格式异常
//                         // 此处可以添加错误处理逻辑
//                     }
//                 }
//                 textReview.setText("" + s); // 将计算结果转换为字符串并显示在审查文本框
//             }

//         } else if (e.getSource() == btns[15]) { // 如果点击的是第15个按钮（数字4）
//             number(btns[15].getText()); // 调用数字输入处理方法
//         } else if (e.getSource() == btns[16]) { // 如果点击的是第16个按钮（数字5）
//             number(btns[16].getText()); // 调用数字输入处理方法
//         } else if (e.getSource() == btns[17]) { // 如果点击的是第17个按钮（数字6）
//             number(btns[17].getText()); // 调用数字输入处理方法
//         } else if (e.getSource() == btns[18]) { // 如果点击的是第18个按钮（*，乘法）
//             math(); // 执行数学运算，确保状态更新
//             str = textResult.getText(); // 获取结果文本框的内容
//             String s = textReview.getText(); // 获取审查文本框的内容
//             textReview.setText(s + str + btns[18].getText()); // 将当前结果和运算符添加到审查文本框
//             textResult.setText("0"); // 清空结果文本框并重置为0
//         } else if (e.getSource() == btns[19]) { // 如果点击的是第19个按钮（1/x，倒数）
//             math(); // 执行数学运算，确保状态更新
//             str = textResult.getText(); // 获取结果文本框的内容
//             if (!str.equalsIgnoreCase("")) { // 如果结果文本框不为空
//                 double s = 0; // 初始化一个double变量用于存储结果
//                 try {
//                     s = Integer.parseInt(str); // 尝试将字符串解析为整数
//                     s = 1.0 / s; // 计算倒数
//                 } catch (NumberFormatException e1) { // 捕获数字格式异常
//                     try {
//                         s = Double.parseDouble(str); // 尝试将字符串解析为双精度浮点数
//                         s = 1.0 / s; // 计算倒数
//                     } catch (NumberFormatException e2) { // 捕获数字格式异常
//                         // 此处可以添加错误处理逻辑
//                     }
//                 }
//                 textResult.setText("" + s); // 将结果显示在结果文本框
//             } else { // 如果结果文本框为空
//                 str = textReview.getText(); // 获取审查文本框的内容
//                 double s = 0; // 初始化一个double变量用于存储结果
//                 try {
//                     s = Integer.parseInt(str); // 尝试将字符串解析为整数
//                     s = 1.0 / s; // 计算倒数
//                 } catch (NumberFormatException e1) { // 捕获数字格式异常
//                     try {
//                         s = Double.parseDouble(str); // 尝试将字符串解析为双精度浮点数
//                         s = 1.0 / s; // 计算倒数
//                     } catch (NumberFormatException e2) { // 捕获数字格式异常
//                         // 此处可以添加错误处理逻辑
//                     }
//                 }
//                 textReview.setText("" + s); // 将结果显示在审查文本框
//             }
//         } else if (e.getSource() == btns[20]) { // 如果点击的是第20个按钮（数字1）
//             number(btns[20].getText()); // 调用数字输入处理方法
//         } else if (e.getSource() == btns[21]) { // 如果点击的是第21个按钮（数字2）
//             number(btns[21].getText()); // 调用数字输入处理方法
//         } else if (e.getSource() == btns[22]) { // 如果点击的是第22个按钮（数字3）
//             number(btns[22].getText()); // 调用数字输入处理方法
//         } else if (e.getSource() == btns[23]) { // 如果点击的是第23个按钮（-，减法）
//             math(); // 执行数学运算，确保状态更新
//             str = textResult.getText(); // 获取结果文本框的内容
//             String s = textReview.getText(); // 获取审查文本框的内容
//             textReview.setText(s + str + btns[23].getText()); // 将当前结果和运算符添加到审查文本框
//             textResult.setText("0"); // 清空结果文本框并重置为0
//         } else if (e.getSource() == btns[24]) { // 如果点击的是第24个按钮（x^2，平方）
//             math(); // 执行数学运算，确保状态更新
//             String str = textResult.getText(); // 获取结果文本框的内容
//             if (!str.equalsIgnoreCase("")) { // 如果结果文本框不为空
//                 try {
//                     long s = Integer.parseInt(str); // 尝试将字符串解析为整数
//                     s = s * s; // 计算平方
//                     textResult.setText("" + s); // 将结果显示在结果文本框
//                 } catch (NumberFormatException e1) { // 捕获数字格式异常
//                     try {
//                         double s = Double.parseDouble(str); // 尝试将字符串解析为双精度浮点数
//                         s = s * s; // 计算平方
//                         textResult.setText("" + s); // 将结果显示在结果文本框
//                     } catch (NumberFormatException e2) { // 捕获数字格式异常
//                         // 此处可以添加错误处理逻辑
//                     }
//                 }
//             } else { // 如果结果文本框为空
//                 str = textReview.getText(); // 获取审查文本框的内容
//                 try {
//                     long s = Integer.parseInt(str); // 尝试将字符串解析为整数
//                     s = s * s; // 计算平方
//                     textReview.setText("" + s); // 将结果显示在审查文本框
//                 } catch (NumberFormatException e1) { // 捕获数字格式异常
//                     try {
//                         double s = Double.parseDouble(str); // 尝试将字符串解析为双精度浮点数
//                         s = s * s; // 计算平方
//                         textReview.setText("" + s); // 将结果显示在审查文本框
//                     } catch (NumberFormatException e2) { // 捕获数字格式异常
//                         // 此处可以添加错误处理逻辑
//                     }
//                 }
//             }
//         } else if (e.getSource() == btns[25]) { // 如果点击的是第25个按钮（数字0）
//             number(btns[25].getText()); // 调用数字输入处理方法
//         } else if (e.getSource() == btns[26]) { // 如果点击的是第26个按钮（.，小数点）
//             str = textResult.getText(); // 获取结果文本框的内容
//             if (str.indexOf('.') == -1) // 如果结果文本框中没有小数点
//                 textResult.setText(str + btns[26].getText()); // 在结果文本框中添加小数点
//         } else if (e.getSource() == btns[27]) { // 如果点击的是第27个按钮（=，等于）
//             math(); // 执行数学运算，确保状态更新
//         } else if (e.getSource() == btns[28]) { // 如果点击的是第28个按钮（+，加法）
//             math(); // 执行数学运算，确保状态更新
//             str = textResult.getText(); // 获取结果文本框的内容
//             String s = textReview.getText(); // 获取审查文本框的内容
//             textReview.setText(s + str + btns[28].getText()); // 将当前结果和运算符添加到审查文本框
//             textResult.setText("0"); // 清空结果文本框并重置为0
//         } else if (e.getSource() == btns[29]) { // 如果点击的是第29个按钮（OFF，关闭）
//             System.exit(0); // 退出程序
//         }
//     }

//     /**
//      * 执行数学运算
//      */
//     private void math() { // 定义一个私有方法，用于执行数学运算
//         String str = textReview.getText() + textResult.getText(); // 获取审查文本框和结果文本框的内容并拼接
//         System.out.println(textReview.getText()); // 打印审查文本框的内容（用于调试）

//         if (str.indexOf('+') != -1) { // 如果当前字符是加法运算符（+）
//             String[] s = str.split("\\+"); // 按加号分割字符串成数组
//             System.out.println(s[0] + "   " + s[1]); // 打印两个操作数（用于调试）
//             try {
//                 int sum = Integer.parseInt(s[0]) + Integer.parseInt(s[1]); // 尝试将两个操作数解析为整数并相加
//                 textResult.setText(""); // 清空结果文本框
//                 textReview.setText("" + sum); // 将计算结果显示在审查文本框
//             } catch (NumberFormatException e1) { // 捕获整数解析异常
//                 try {
//                     double sum = Double.parseDouble(s[0]) + Double.parseDouble(s[1]); // 尝试将两个操作数解析为浮点数并相加
//                     textResult.setText(""); // 清空结果文本框
//                     textReview.setText("" + sum); // 将计算结果显示在审查文本框
//                 } catch (NumberFormatException e2) { // 捕获浮点数解析异常
//                     e2.printStackTrace(); // 打印异常堆栈跟踪（用于调试）
//                 }
//             }
//         }

//         if (str.indexOf('-') != -1) { // 如果当前字符是减法运算符（-）
//             String[] s = str.split("\\-"); // 按减号分割字符串成数组
//             if (str.charAt(0) == '-') { // 如果字符串以负号开头
//                 s[s.length - 2] = "-" + s[s.length - 2]; // 将减去的数的符号变为负
//                 /*
//                  * str.charAt(0) == '-'：检查字符串的第一个字符是否为负号。
//                  * 如果是，则认为表达式是一个负数，接下来的操作数（即减去的数）也应为负数。
//                  * 
//                  * s[s.length - 2] = "-" + s[s.length - 2];：
//                  * 找到数组 s 中倒数第二个元素（即被减数），将其前面加上一个负号，从而将它的符号变为负。
//                  * 这是为了确保在后续的减法操作中，计算时能正确处理负数。
//                  */
//             }
//             try {
//                 int sum = Integer.parseInt(s[s.length - 2]) - Integer.parseInt(s[s.length - 1]); // 尝试将操作数解析为整数并相减
//                 textResult.setText(""); // 清空结果文本框
//                 textReview.setText("" + sum); // 将计算结果显示在审查文本框
//             } catch (NumberFormatException e1) { // 捕获整数解析异常
//                 try {
//                     double sum = Double.parseDouble(s[0]) - Double.parseDouble(s[1]); // 尝试将操作数解析为浮点数并相减
//                     textResult.setText(""); // 清空结果文本框
//                     textReview.setText("" + sum); // 将计算结果显示在审查文本框
//                 } catch (NumberFormatException e2) { // 捕获浮点数解析异常
//                     // 处理异常
//                 }
//             }
//         }

//         if (str.indexOf('*') != -1) { // 如果当前字符是乘法运算符（*）
//             String[] s = str.split("\\*"); // 按乘号分割字符串成数组
//             try {
//                 int sum = Integer.parseInt(s[0]) * Integer.parseInt(s[1]); // 尝试将操作数解析为整数并相乘
//                 textResult.setText(""); // 清空结果文本框
//                 textReview.setText("" + sum); // 将计算结果显示在审查文本框
//             } catch (NumberFormatException e1) { // 捕获整数解析异常
//                 try {
//                     double sum = Double.parseDouble(s[0]) * Double.parseDouble(s[1]); // 尝试将操作数解析为浮点数并相乘
//                     textResult.setText(""); // 清空结果文本框
//                     textReview.setText("" + sum); // 将计算结果显示在审查文本框
//                 } catch (NumberFormatException e2) { // 捕获浮点数解析异常
//                     e2.printStackTrace(); // 打印异常堆栈跟踪（用于调试）
//                 }
//             }
//         }

//         if (str.indexOf('/') != -1) { // 如果当前字符是除法运算符（/）
//             String[] s = str.split("\\/"); // 按除号分割字符串成数组
//             if (s[1].equals("0")) { // 如果除数为0
//                 textResult.setText("除数不能为0！"); // 显示错误信息
//                 textReview.setText(""); // 显示错误信息
//                 return; // 退出方法
//             }
//             try {
//                 if (Integer.parseInt(s[0]) % Integer.parseInt(s[1]) == 0) { // 检查是否可以整除
//                     int sum = Integer.parseInt(s[0]) / Integer.parseInt(s[1]); // 执行整数除法
//                     textResult.setText(""); // 清空结果文本框
//                     textReview.setText("" + sum); // 将计算结果显示在审查文本框
//                 } else {
//                     double sum = 1.0 * Integer.parseInt(s[0]) / Integer.parseInt(s[1]); // 执行浮点数除法
//                     textResult.setText(""); // 清空结果文本框
//                     textReview.setText("" + sum); // 将计算结果显示在审查文本框
//                 }
//             } catch (NumberFormatException e1) { // 捕获整数解析异常
//                 try {
//                     double sum = Double.parseDouble(s[0]) / Double.parseDouble(s[1]); // 尝试将操作数解析为浮点数并执行除法
//                     textResult.setText(""); // 清空结果文本框
//                     textReview.setText("" + sum); // 将计算结果显示在审查文本框
//                 } catch (NumberFormatException e2) { // 捕获浮点数解析异常
//                     e2.printStackTrace(); // 打印异常堆栈跟踪（用于调试）
//                 }
//             }
//         }
//     }

//     /**
//      * 处理数字按钮的输入
//      * 
//      * @param text 输入的数字文本
//      */
//     private void number(String text) { // 定义一个私有方法，用于处理数字按钮的输入
//         str = textResult.getText(); // 获取结果文本框中的当前文本并赋值给str
//         try { // 尝试执行以下代码块
//             int s = Integer.parseInt(str); // 将当前文本解析为整数
//             if (s == 0) { // 如果当前值为0
//                 textResult.setText(text); // 将结果文本框的内容设置为当前按钮的文本
//             } else { // 如果当前值不为0
//                 textResult.setText(str + text); // 将当前文本与按钮文本拼接后再次设置到结果文本框
//             }
//         } catch (NumberFormatException e1) { // 捕获整数解析的异常
//             try { // 尝试执行以下代码块
//                 double s = Double.parseDouble(str); // 将当前文本解析为双精度浮点数
//                 textResult.setText(str + text); // 将当前文本与按钮文本拼接后再次设置到结果文本框
//             } catch (NumberFormatException e2) { // 捕获双精度浮点数解析的异常
//                 // e2.printStackTrace(); // 此处可以添加错误处理，例如打印错误堆栈
//             }
//         }
//     }

//     /**
//      * 主程序入口
//      * 
//      * @param args 命令行参数
//      */
//     public static void main(String[] args) {
//         new Calculator("计算器");
//     }

//     @Override
//     public void caretUpdate(CaretEvent e) {
//         // TODO Auto-generated method stub
//     }
// }

package JiSuanQi;

import java.awt.BorderLayout;
import java.awt.Button;
import java.awt.Color;
import java.awt.FlowLayout;
import java.awt.Font;
import java.awt.GridLayout;
import java.awt.HeadlessException;
import java.awt.Insets;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.font.ShapeGraphicAttribute;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JTextArea;
import javax.swing.JTextField;
import javax.swing.event.CaretEvent;
import javax.swing.event.CaretListener;

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;

import java.awt.Desktop; // 添加这一行以导入Desktop类

/**
 * 计算器类，继承自JFrame，实现了ActionListener和CaretListener接口
 * 
 * JFrame：
 * JFrame 是 Swing 包中的一个类，用于创建一个窗口界面。它是所有顶层窗口的基本类型，提供了图形用户界面的框架。
 * JFrame 可以包含各种图形组件，如按钮、标签、文本框等，通过设置布局管理器，用户可以控制这些组件的显示方式。
 * 主要的功能包括设置窗口标题、设置窗口大小、设置关闭操作、添加组件和显示窗口等。
 * 
 * ActionListener：
 * ActionListener 是一个接口，用于处理按钮点击等动作事件。当用户在 GUI 中执行某个动作（如点击按钮）时，将触发相应的事件。
 * 开发者需要实现 actionPerformed(ActionEvent e) 方法，以定义在事件发生时应该执行的操作。
 * 通过为组件（如按钮）添加这个监听器，可以响应用户的交互。
 * 
 * CaretListener：
 * CaretListener 也是一个接口，用于监听文本组件（如 JTextField 或 JTextArea）中光标的移动事件。
 * 当文本框中的光标位置变化时，将触发 caretUpdate(CaretEvent e)
 * 方法，开发者可以在这个方法中处理光标移动后的逻辑，例如更新某些组件的状态或者显示相关信息。
 * 这个监听器通常用来监控用户在文本框中进行输入或删除操作后的光标位置变化
 */
public class Calculator extends JFrame implements ActionListener, CaretListener { // 定义Calculator类，继承自JFrame并实现ActionListener和CaretListener接口
    private JTextField textResult, textReview; // 定义两个文本框，一个用于显示结果，另一个用于显示输入的数学表达式
    private JButton btns[] = new JButton[30]; // 定义一个按钮数组，预留30个按钮
    // private String str1, str2; // str1用于存储历史输入的数学表达式，str2用于存储当前输入的数学表达式
    private String str;
    private String memory;

    /**
     * 构造方法，初始化计算器界面和组件
     * 
     * @param str 窗口标题
     */
    public Calculator(String str) { // 构造方法接收窗口标题参数
        super(str); // 调用父类构造方法设置窗口标题
        this.setBounds(600, 150, 420, 520); // 设置窗口的大小和位置
        this.setDefaultCloseOperation(EXIT_ON_CLOSE); // 设置关闭窗口时退出程序
        this.setResizable(false); // 不允许调整窗口大小
        this.getContentPane().setBackground(Color.lightGray); // 设置内容面板的背景颜色
        this.getContentPane().setLayout(new BorderLayout()); // 设置布局为边界布局

        JPanel p1 = new JPanel(); // 创建一个新的JPanel
        p1.setLayout(new BorderLayout(0, 0)); // 设置面板的布局为边界布局

        // 初始化文本框
        textResult = createTextField("0", 20);
        textReview = createTextField(textResult.getText(), 12);
        textReview.setEditable(false); // 设置审查文本框为只读

        // 设置面板及文本框布局
        setupPanels(p1);

        this.getContentPane().add(p1, BorderLayout.NORTH); // 将主面板添加到内容面板的北部

        JPanel p2 = new JPanel(); // 创建一个面板用于放置按钮
        p2.setLayout(new GridLayout(6, 5, 10, 10)); // 设置为6行5列的网格布局
        btns = get(btns); // 初始化按钮数组
        setupButtons(p2); // 设置按钮

        this.getContentPane().add(p2, BorderLayout.CENTER); // 将按钮面板添加到内容面板的中心

        // 添加文本监听器
        textResult.addCaretListener(this); // 为结果文本框添加光标监听器
        textReview.addCaretListener(this); // 为审查文本框添加光标监听器
        this.setVisible(true); // 设置窗口可见
    }

    /**
     * 创建文本框的方法
     */
    private JTextField createTextField(String text, int fontSize) {
        JTextField textField = new JTextField(text, 5);
        textField.setHorizontalAlignment(JTextField.RIGHT); // 设置文本框内容右对齐
        textField.setFont(new Font("Arial", Font.BOLD, fontSize)); // 设置文本框字体
        return textField;
    }

    /**
     * 设置面板及文本框布局
     */
    private void setupPanels(JPanel p1) {
        p1.add(createPanel(textReview, textResult), BorderLayout.CENTER);
        p1.add(new JPanel(), BorderLayout.WEST); // 西部面板
        p1.add(new JPanel(), BorderLayout.EAST); // 东部面板
        p1.add(new JPanel(), BorderLayout.SOUTH); // 南部面板
    }

    /**
     * 创建包含两个文本框的显示面板
     */
    private JPanel createPanel(JTextField topField, JTextField bottomField) {
        JPanel panel = new JPanel();
        panel.setLayout(new GridLayout(2, 1, 0, -2)); // 设置为2行1列的网格布局
        panel.add(topField); // 添加审查文本框
        panel.add(bottomField); // 添加结果文本框
        return panel;
    }

    /**
     * 设置按钮的方法
     */
    private void setupButtons(JPanel p2) {
        for (JButton btn : btns) { // 遍历按钮数组
            p2.add(btn); // 将每个按钮添加到面板中
            btn.setMargin(new Insets(0, 0, 0, 0)); // 设置按钮的边缘空余部分为0
            btn.setFont(new Font("Arial", Font.ROMAN_BASELINE, btn == btns[btns.length - 1] ? 12 : 15)); // 设置字体
            btn.addActionListener(this); // 为每个按钮添加事件监听器
        }
    }

    /**
     * 获取按钮数组并初始化按钮
     * 
     * @param btns2 按钮数组
     * @return 初始化后的按钮数组
     */
    private JButton[] get(JButton[] btns2) {
        String[] buttonLabels = {
                "MC", "MR", "MS", "M+", "M-",
                "←", "CE", "C", "±", "√",
                "7", "8", "9", "/", "%",
                "4", "5", "6", "*", "1/x",
                "1", "2", "3", "-", "x^2",
                "0", ".", "=", "+", "OpenHistory"
        };

        for (int i = 0; i < btns.length; i++) {
            try {
                btns[i] = new JButton(buttonLabels[i]); // 初始化按钮
            } catch (ArrayIndexOutOfBoundsException e) {
                System.err.println("按钮初始化异常：" + e.getMessage()); // 错误处理
            }
        }

        return btns; // 返回初始化后的按钮数组
    }

    /**
     * 处理按钮的点击事件
     */
    public void actionPerformed(ActionEvent e) { // 实现ActionListener接口中的方法，处理按钮点击事件
        /*
         * MC（Memory Clear）：清除存储器中的数值。
         * MR（Memory Recall）：读取存储器中存储的数值。
         * MS（Memory Save）：将当前显示的数值存入存储器中。
         * M+（Memory Add）：将当前显示的数值与存储器中的数值相加，并将结果存入存储器。
         * M-（Memory Minus，部分计算器无此功能）：用存储器中的数值减去当前显示的数值，并将结果存入存储器（此功能并非所有计算器都具备）。
         */
        if (e.getSource() == btns[0]) { // 如果点击的是第0个按钮（MC）
            memory = "0"; // 将存储器中的数值清零
        } else if (e.getSource() == btns[1]) { // 如果点击的是第1个按钮（MR）
            str = memory; // 将结果文本框的内容设置为存储器中的数值
            textResult.setText(str);
        } else if (e.getSource() == btns[2]) { // 如果点击的是第2个按钮（MS）
            memory = textResult.getText(); // 将存储器中的数值设置为结果文本框的内容
        } else if (e.getSource() == btns[3]) { // 如果点击的是第3个按钮（M+）
            String str = memory + "+" + textResult.getText();
            String[] s = str.split("\\+"); // 按加号分割字符串成数组
            System.out.println(s[0] + "   " + s[1]); // 打印两个操作数（用于调试）
            try {
                int sum = Integer.parseInt(s[0]) + Integer.parseInt(s[1]); // 尝试将两个操作数解析为整数并相加
                memory = String.valueOf(sum); // 更新存储器中的数值
            } catch (NumberFormatException e1) { // 捕获整数解析异常
                try {
                    double sum = Double.parseDouble(s[0]) + Double.parseDouble(s[1]); // 尝试将两个操作数解析为浮点数并相加
                    memory = String.valueOf(sum); // 更新存储器中的数值
                } catch (NumberFormatException e2) { // 捕获浮点数解析异常
                    e2.printStackTrace(); // 打印异常堆栈跟踪（用于调试）
                }
            }
        } else if (e.getSource() == btns[4]) { // 如果点击的是第4个按钮（M-）
            String str = memory + "-" + textResult.getText();
            String[] s = str.split("\\-"); // 按减号分割字符串成数组
            if (str.charAt(0) == '-') { // 如果字符串以负号开头
                s[s.length - 2] = "-" + s[s.length - 2]; // 将减去的数的符号变为负
                /*
                 * str.charAt(0) == '-'：检查字符串的第一个字符是否为负号。
                 * 如果是，则认为表达式是一个负数，接下来的操作数（即减去的数）也应为负数。
                 * 
                 * s[s.length - 2] = "-" + s[s.length - 2];：
                 * 找到数组 s 中倒数第二个元素（即被减数），将其前面加上一个负号，从而将它的符号变为负。
                 * 这是为了确保在后续的减法操作中，计算时能正确处理负数。
                 */
            }
            try {
                int sum = Integer.parseInt(s[s.length - 2]) - Integer.parseInt(s[s.length - 1]); // 尝试将操作数解析为整数并相减
                memory = String.valueOf(sum); // 更新存储器中的数值
            } catch (NumberFormatException e1) { // 捕获整数解析异常
                try {
                    double sum = Double.parseDouble(s[0]) - Double.parseDouble(s[1]); // 尝试将操作数解析为浮点数并相减
                    memory = String.valueOf(sum); // 更新存储器中的数值
                } catch (NumberFormatException e2) { // 捕获浮点数解析异常
                    // 处理异常
                }
            }
        } else if (e.getSource() == btns[5]) { // 如果点击的是第5个按钮（←，退格）
            // str2 = textResult.getText(); // 获取结果文本框的内容
            // if (str2.length() == 1) { // 如果字符串长度为1
            // textResult.setText("0"); // 设置结果文本框为0
            // } else { // 如果字符串长度大于1
            // str2 = str2.substring(0, str.length() - 1);
            // // System.out.println(str.length()); // 打印字符串的长度（用于调试）
            // textResult.setText(str2); // 更新结果文本框为新字符串
            // }
            str = textResult.getText(); // 获取结果文本框的内容
            if (str.length() == 1) { // 如果字符串长度为1
                textResult.setText("0"); // 设置结果文本框为0
            } else { // 如果字符串长度大于1
                str = str.substring(0, str.length() - 1);
                // System.out.println(str.length()); // 打印字符串的长度（用于调试）
                textResult.setText(str); // 更新结果文本框为新字符串
            }
        } else if (e.getSource() == btns[6]) { // 如果点击的是第6个按钮（CE，清除当前输入）
            // str2 = "0";
            textResult.setText("0"); // 清空审查文本框
        } else if (e.getSource() == btns[7]) { // 如果点击的是第7个按钮（C，清除所有）
            textResult.setText("0"); // 将结果文本框清空并设置为0
            textReview.setText(""); // 清空审查文本框
        } else if (e.getSource() == btns[8]) { // 如果点击的是第8个按钮（±，正负号切换）
            math(); // 先执行数学运算（以确保状态更新）
            String str = textReview.getText(); // 获取审查文本框的内容
            str = str.startsWith("-") ? str.substring(1, str.length()) : "-" + str; // 取反
            textReview.setText(str); // 更新审查文本框为新字符串
        } else if (e.getSource() == btns[9]) { // 如果点击的是第9个按钮（√，开方）
            math(); // 执行数学运算，确保状态更新
            String str = textResult.getText(); // 获取结果文本框的内容
            if (!str.equalsIgnoreCase("")) { // 如果结果文本框不为空
                double s = 0; // 初始化一个double变量用于存储结果
                try {
                    s = Double.parseDouble(str); // 尝试将字符串解析为双精度浮点数
                    s = Math.sqrt(s); // 计算s的平方根
                } catch (NumberFormatException e2) { // 捕获数字格式异常
                    // 此处可以添加错误处理逻辑
                }
                textReview.setText("" + s); // 将计算结果转换为字符串并显示在结果文本框
                textResult.setText("0"); // 清空结果文本框并重置为0
            } else { // 如果结果文本框为空
                str = textReview.getText(); // 获取审查文本框的内容
                double s = 0; // 初始化一个double变量用于存储结果
                try {
                    s = Double.parseDouble(str); // 尝试将字符串解析为双精度浮点数
                    s = Math.sqrt(s); // 计算s的平方根
                } catch (NumberFormatException e2) { // 捕获数字格式异常
                    // 此处可以添加错误处理逻辑
                }
                textReview.setText("" + s); // 将计算结果转换为字符串并显示在审查文本框
            }
        } else if (e.getSource() == btns[10]) { // 如果点击的是第10个按钮（数字7）
            number(btns[10].getText()); // 调用数字输入处理方法，传入按钮的文本
        } else if (e.getSource() == btns[11]) { // 如果点击的是第11个按钮（数字8）
            number(btns[11].getText()); // 调用数字输入处理方法
        } else if (e.getSource() == btns[12]) { // 如果点击的是第12个按钮（数字9）
            number(btns[12].getText()); // 调用数字输入处理方法
        } else if (e.getSource() == btns[13]) { // 如果点击的是第13个按钮（/，除法）
            math(); // 执行数学运算，确保状态更新
            str = textResult.getText(); // 获取结果文本框的内容
            String s = textReview.getText(); // 获取审查文本框的内容
            textReview.setText(s + str + btns[13].getText()); // 将当前结果和运算符添加到审查文本框
            textResult.setText("0"); // 清空结果文本框并重置为0
        } else if (e.getSource() == btns[14]) { // 如果点击的是第14个按钮（%）
            math(); // 执行数学运算，确保状态更新
            String str = textResult.getText(); // 获取结果文本框的内容
            if (!str.equalsIgnoreCase("")) { // 如果结果文本框不为空
                double s = 0; // 初始化一个double变量用于存储结果
                try {
                    s = Integer.parseInt(str) * 1.00 / 100; // 尝试将字符串解析为整数并转换为百分比
                } catch (NumberFormatException e1) { // 捕获数字格式异常
                    try {
                        s = Double.parseDouble(str) / 100; // 尝试将字符串解析为双精度浮点数并转换为百分比
                    } catch (NumberFormatException e2) { // 捕获数字格式异常
                        // 此处可以添加错误处理逻辑
                    }
                }
                textResult.setText("" + s); // 将计算结果转换为字符串并显示在结果文本框
            } else { // 如果结果文本框为空
                str = textReview.getText(); // 获取审查文本框的内容
                double s = 0; // 初始化一个double变量用于存储结果
                try {
                    s = Integer.parseInt(str) * 1.00 / 100; // 尝试将字符串解析为整数并转换为百分比
                } catch (NumberFormatException e1) { // 捕获数字格式异常
                    try {
                        s = Double.parseDouble(str) / 100; // 尝试将字符串解析为双精度浮点数并转换为百分比
                    } catch (NumberFormatException e2) { // 捕获数字格式异常
                        // 此处可以添加错误处理逻辑
                    }
                }
                textReview.setText("" + s); // 将计算结果转换为字符串并显示在审查文本框
            }

        } else if (e.getSource() == btns[15]) { // 如果点击的是第15个按钮（数字4）
            number(btns[15].getText()); // 调用数字输入处理方法
        } else if (e.getSource() == btns[16]) { // 如果点击的是第16个按钮（数字5）
            number(btns[16].getText()); // 调用数字输入处理方法
        } else if (e.getSource() == btns[17]) { // 如果点击的是第17个按钮（数字6）
            number(btns[17].getText()); // 调用数字输入处理方法
        } else if (e.getSource() == btns[18]) { // 如果点击的是第18个按钮（*，乘法）
            math(); // 执行数学运算，确保状态更新
            str = textResult.getText(); // 获取结果文本框的内容
            String s = textReview.getText(); // 获取审查文本框的内容
            textReview.setText(s + str + btns[18].getText()); // 将当前结果和运算符添加到审查文本框
            textResult.setText("0"); // 清空结果文本框并重置为0
        } else if (e.getSource() == btns[19]) { // 如果点击的是第19个按钮（1/x，倒数）
            math(); // 执行数学运算，确保状态更新
            str = textResult.getText(); // 获取结果文本框的内容
            if (!str.equalsIgnoreCase("")) { // 如果结果文本框不为空
                double s = 0; // 初始化一个double变量用于存储结果
                try {
                    s = Integer.parseInt(str); // 尝试将字符串解析为整数
                    s = 1.0 / s; // 计算倒数
                } catch (NumberFormatException e1) { // 捕获数字格式异常
                    try {
                        s = Double.parseDouble(str); // 尝试将字符串解析为双精度浮点数
                        s = 1.0 / s; // 计算倒数
                    } catch (NumberFormatException e2) { // 捕获数字格式异常
                        // 此处可以添加错误处理逻辑
                    }
                }
                textResult.setText("" + s); // 将结果显示在结果文本框
            } else { // 如果结果文本框为空
                str = textReview.getText(); // 获取审查文本框的内容
                double s = 0; // 初始化一个double变量用于存储结果
                try {
                    s = Integer.parseInt(str); // 尝试将字符串解析为整数
                    s = 1.0 / s; // 计算倒数
                } catch (NumberFormatException e1) { // 捕获数字格式异常
                    try {
                        s = Double.parseDouble(str); // 尝试将字符串解析为双精度浮点数
                        s = 1.0 / s; // 计算倒数
                    } catch (NumberFormatException e2) { // 捕获数字格式异常
                        // 此处可以添加错误处理逻辑
                    }
                }
                textReview.setText("" + s); // 将结果显示在审查文本框
            }
        } else if (e.getSource() == btns[20]) { // 如果点击的是第20个按钮（数字1）
            number(btns[20].getText()); // 调用数字输入处理方法
        } else if (e.getSource() == btns[21]) { // 如果点击的是第21个按钮（数字2）
            number(btns[21].getText()); // 调用数字输入处理方法
        } else if (e.getSource() == btns[22]) { // 如果点击的是第22个按钮（数字3）
            number(btns[22].getText()); // 调用数字输入处理方法
        } else if (e.getSource() == btns[23]) { // 如果点击的是第23个按钮（-，减法）
            math(); // 执行数学运算，确保状态更新
            str = textResult.getText(); // 获取结果文本框的内容
            String s = textReview.getText(); // 获取审查文本框的内容
            textReview.setText(s + str + btns[23].getText()); // 将当前结果和运算符添加到审查文本框
            textResult.setText("0"); // 清空结果文本框并重置为0
        } else if (e.getSource() == btns[24]) { // 如果点击的是第24个按钮（x^2，平方）
            math(); // 执行数学运算，确保状态更新
            String str = textResult.getText(); // 获取结果文本框的内容
            if (!str.equalsIgnoreCase("")) { // 如果结果文本框不为空
                try {
                    long s = Integer.parseInt(str); // 尝试将字符串解析为整数
                    s = s * s; // 计算平方
                    textResult.setText("" + s); // 将结果显示在结果文本框
                } catch (NumberFormatException e1) { // 捕获数字格式异常
                    try {
                        double s = Double.parseDouble(str); // 尝试将字符串解析为双精度浮点数
                        s = s * s; // 计算平方
                        textResult.setText("" + s); // 将结果显示在结果文本框
                    } catch (NumberFormatException e2) { // 捕获数字格式异常
                        // 此处可以添加错误处理逻辑
                    }
                }
            } else { // 如果结果文本框为空
                str = textReview.getText(); // 获取审查文本框的内容
                try {
                    long s = Integer.parseInt(str); // 尝试将字符串解析为整数
                    s = s * s; // 计算平方
                    textReview.setText("" + s); // 将结果显示在审查文本框
                } catch (NumberFormatException e1) { // 捕获数字格式异常
                    try {
                        double s = Double.parseDouble(str); // 尝试将字符串解析为双精度浮点数
                        s = s * s; // 计算平方
                        textReview.setText("" + s); // 将结果显示在审查文本框
                    } catch (NumberFormatException e2) { // 捕获数字格式异常
                        // 此处可以添加错误处理逻辑
                    }
                }
            }
        } else if (e.getSource() == btns[25]) { // 如果点击的是第25个按钮（数字0）
            number(btns[25].getText()); // 调用数字输入处理方法
        } else if (e.getSource() == btns[26]) { // 如果点击的是第26个按钮（.，小数点）
            str = textResult.getText(); // 获取结果文本框的内容
            if (str.indexOf('.') == -1) // 如果结果文本框中没有小数点
                textResult.setText(str + btns[26].getText()); // 在结果文本框中添加小数点
        } else if (e.getSource() == btns[27]) { // 如果点击的是第27个按钮（=，等于）
            saveExpressionToFile(textReview.getText() + textResult.getText() + "=", false); // 保存表达式到文件，并不换行

            math(); // 执行数学运算，确保状态更新

            saveExpressionToFile(textReview.getText(), true); // 保存结果到文件

        } else if (e.getSource() == btns[28]) { // 如果点击的是第28个按钮（+，加法）
            math(); // 执行数学运算，确保状态更新
            str = textResult.getText(); // 获取结果文本框的内容
            String s = textReview.getText(); // 获取审查文本框的内容
            textReview.setText(s + str + btns[28].getText()); // 将当前结果和运算符添加到审查文本框
            textResult.setText("0"); // 清空结果文本框并重置为0
        } else if (e.getSource() == btns[29]) { // 如果点击的是“查看历史”按钮
            viewHistory(); // 调用查看历史的方法
        }
    }

    private void viewHistory() {
        // 指定要打开的文件路径
        File historyFile = new File("calculation_history.txt");
        if (historyFile.exists()) { // 检查文件是否存在
            try {
                Desktop.getDesktop().open(historyFile); // 打开文件
            } catch (IOException e) {
                e.printStackTrace(); // 处理异常
            }
        } else {
            // 文件不存在，尝试创建该文件
            try {
                if (historyFile.createNewFile()) { // 创建新文件
                    System.out.println("历史记录文件已创建！");
                    JOptionPane.showMessageDialog(this, "历史记录文件已创建！", "提示", JOptionPane.INFORMATION_MESSAGE);
                } else {
                    System.out.println("无法创建历史记录文件！");
                    JOptionPane.showMessageDialog(this, "无法创建历史记录文件！", "错误", JOptionPane.ERROR_MESSAGE);
                }
            } catch (IOException e) {
                e.printStackTrace(); // 打印异常堆栈
                System.out.println("创建历史记录文件时出错！");
                JOptionPane.showMessageDialog(this, "创建历史记录文件时出错！", "错误", JOptionPane.ERROR_MESSAGE);
            }
        }
    }

    // 保存表达式和结果到文件的方法
    private void saveExpressionToFile(String expression, boolean isNewLine) {
        try (BufferedWriter writer = new BufferedWriter(new FileWriter("calculation_history.txt", true))) { // 以追加模式打开文件
            writer.write(expression); // 写入表达式
            if (isNewLine)
                writer.newLine(); // 换行
        } catch (IOException e) {
            e.printStackTrace(); // 处理异常
        }
    }

    /**
     * 执行数学运算
     */
    private void math() { // 定义一个私有方法，用于执行数学运算
        String str = textReview.getText() + textResult.getText(); // 获取审查文本框和结果文本框的内容并拼接
        System.out.println(textReview.getText()); // 打印审查文本框的内容（用于调试）

        if (str.indexOf('+') != -1) { // 如果当前字符是加法运算符（+）
            String[] s = str.split("\\+"); // 按加号分割字符串成数组
            System.out.println(s[0] + "   " + s[1]); // 打印两个操作数（用于调试）
            try {
                int sum = Integer.parseInt(s[0]) + Integer.parseInt(s[1]); // 尝试将两个操作数解析为整数并相加
                textResult.setText(""); // 清空结果文本框
                textReview.setText("" + sum); // 将计算结果显示在审查文本框
            } catch (NumberFormatException e1) { // 捕获整数解析异常
                try {
                    double sum = Double.parseDouble(s[0]) + Double.parseDouble(s[1]); // 尝试将两个操作数解析为浮点数并相加
                    textResult.setText(""); // 清空结果文本框
                    textReview.setText("" + sum); // 将计算结果显示在审查文本框
                } catch (NumberFormatException e2) { // 捕获浮点数解析异常
                    e2.printStackTrace(); // 打印异常堆栈跟踪（用于调试）
                }
            }
        } else if (str.indexOf('-') != -1) { // 如果当前字符是减法运算符（-）
            String[] s = str.split("\\-"); // 按减号分割字符串成数组
            if (str.charAt(0) == '-') { // 如果字符串以负号开头
                s[s.length - 2] = "-" + s[s.length - 2]; // 将减去的数的符号变为负
                /*
                 * str.charAt(0) == '-'：检查字符串的第一个字符是否为负号。
                 * 如果是，则认为表达式是一个负数，接下来的操作数（即减去的数）也应为负数。
                 * 
                 * s[s.length - 2] = "-" + s[s.length - 2];：
                 * 找到数组 s 中倒数第二个元素（即被减数），将其前面加上一个负号，从而将它的符号变为负。
                 * 这是为了确保在后续的减法操作中，计算时能正确处理负数。
                 */
            }
            try {
                int sum = Integer.parseInt(s[s.length - 2]) - Integer.parseInt(s[s.length - 1]); // 尝试将操作数解析为整数并相减
                textResult.setText(""); // 清空结果文本框
                textReview.setText("" + sum); // 将计算结果显示在审查文本框
            } catch (NumberFormatException e1) { // 捕获整数解析异常
                try {
                    double sum = Double.parseDouble(s[0]) - Double.parseDouble(s[1]); // 尝试将操作数解析为浮点数并相减
                    textResult.setText(""); // 清空结果文本框
                    textReview.setText("" + sum); // 将计算结果显示在审查文本框
                } catch (NumberFormatException e2) { // 捕获浮点数解析异常
                    // 处理异常
                }
            }
        } else if (str.indexOf('*') != -1) { // 如果当前字符是乘法运算符（*）
            String[] s = str.split("\\*"); // 按乘号分割字符串成数组
            try {
                int sum = Integer.parseInt(s[0]) * Integer.parseInt(s[1]); // 尝试将操作数解析为整数并相乘
                textResult.setText(""); // 清空结果文本框
                textReview.setText("" + sum); // 将计算结果显示在审查文本框
            } catch (NumberFormatException e1) { // 捕获整数解析异常
                try {
                    double sum = Double.parseDouble(s[0]) * Double.parseDouble(s[1]); // 尝试将操作数解析为浮点数并相乘
                    textResult.setText(""); // 清空结果文本框
                    textReview.setText("" + sum); // 将计算结果显示在审查文本框
                } catch (NumberFormatException e2) { // 捕获浮点数解析异常
                    e2.printStackTrace(); // 打印异常堆栈跟踪（用于调试）
                }
            }
        } else if (str.indexOf('/') != -1) { // 如果当前字符是除法运算符（/）
            String[] s = str.split("\\/"); // 按除号分割字符串成数组
            if (s[1].equals("0")) { // 如果除数为0
                textResult.setText("除数不能为0！"); // 显示错误信息
                textReview.setText(""); // 显示错误信息
                return; // 退出方法
            }
            try {
                if (Integer.parseInt(s[0]) % Integer.parseInt(s[1]) == 0) { // 检查是否可以整除
                    int sum = Integer.parseInt(s[0]) / Integer.parseInt(s[1]); // 执行整数除法
                    textResult.setText(""); // 清空结果文本框
                    textReview.setText("" + sum); // 将计算结果显示在审查文本框
                } else {
                    double sum = 1.0 * Integer.parseInt(s[0]) / Integer.parseInt(s[1]); // 执行浮点数除法
                    textResult.setText(""); // 清空结果文本框
                    textReview.setText("" + sum); // 将计算结果显示在审查文本框
                }
            } catch (NumberFormatException e1) { // 捕获整数解析异常
                try {
                    double sum = Double.parseDouble(s[0]) / Double.parseDouble(s[1]); // 尝试将操作数解析为浮点数并执行除法
                    textResult.setText(""); // 清空结果文本框
                    textReview.setText("" + sum); // 将计算结果显示在审查文本框
                } catch (NumberFormatException e2) { // 捕获浮点数解析异常
                    e2.printStackTrace(); // 打印异常堆栈跟踪（用于调试）
                }
            }
        }
    }

    /**
     * 解析操作数，可以是整数或浮点数
     * 
     * @param operandStr 操作数字符串
     * @return 解析后的操作数
     * @throws NumberFormatException 如果解析失败
     */
    private double parseOperand(String operandStr) throws NumberFormatException {
        return Double.parseDouble(operandStr); // 尝试将字符串解析为浮点数
    }

    /**
     * 根据操作符执行相应的数学运算
     * 
     * @param operand1 第一个操作数
     * @param operand2 第二个操作数
     * @param operator 运算符
     * @return 运算结果
     */
    private double performOperation(double operand1, double operand2, String operator) {
        switch (operator) {
            case "+":
                return operand1 + operand2;
            case "-":
                return operand1 - operand2;
            case "*":
                return operand1 * operand2;
            case "/":
                if (operand2 == 0) { // 检查除数是否为0
                    throw new ArithmeticException("除数不能为0！"); // 抛出异常
                }
                return operand1 / operand2;
            default:
                throw new IllegalArgumentException("未知运算符: " + operator); // 抛出异常
        }
    }

    /**
     * 处理数字按钮的输入
     * 
     * @param text 输入的数字文本
     */
    private void number(String text) { // 定义一个私有方法，用于处理数字按钮的输入
        str = textResult.getText(); // 获取结果文本框中的当前文本并赋值给str
        try { // 尝试执行以下代码块
            int s = Integer.parseInt(str); // 将当前文本解析为整数
            if (s == 0) { // 如果当前值为0
                textResult.setText(text); // 将结果文本框的内容设置为当前按钮的文本
            } else { // 如果当前值不为0
                textResult.setText(str + text); // 将当前文本与按钮文本拼接后再次设置到结果文本框
            }
        } catch (NumberFormatException e1) { // 捕获整数解析的异常
            try { // 尝试执行以下代码块
                double s = Double.parseDouble(str); // 将当前文本解析为双精度浮点数
                textResult.setText(str + text); // 将当前文本与按钮文本拼接后再次设置到结果文本框
            } catch (NumberFormatException e2) { // 捕获双精度浮点数解析的异常
                // e2.printStackTrace(); // 此处可以添加错误处理，例如打印错误堆栈
            }
        }
    }

    /**
     * 主程序入口
     * 
     * @param args 命令行参数
     */
    public static void main(String[] args) {
        new Calculator("计算器");
    }

    @Override
    public void caretUpdate(CaretEvent e) {
        // TODO Auto-generated method stub
    }
}